# fmt: off
# Generated by the protocol buffer compiler.  DO NOT EDIT!
from __future__ import annotations
from datetime import datetime, timedelta
import enum
from typing import Any, Dict, List, Optional, TypeVar, Type
from google.protobuf import timestamp_pb2
from google.protobuf import duration_pb2
from google.protobuf.json_format import MessageToDict

from continual.rpc.management.v1 import management_types_pb2
from continual.rpc.management.v1 import management_pb2

from google import protobuf

T = TypeVar("T")

def _to_proto_dict(x: dict) -> dict:
    """Converts dict to proto friendly representation."""
    out = dict()
    for key, item in x.items():
        if isinstance(item, list):
            out_list = []
            for e in item:
                if isinstance(e, datetime):
                    dt = timestamp_pb2.Timestamp()
                    dt.FromDatetime(e)
                    out_list.append(dt)
                elif isinstance(e, timedelta):
                    td = duration_pb2.Duration()
                    td.FromTimedelta(e)
                    out_list.append(td)
                elif hasattr(e, "to_proto"):
                    out_list.append(e.to_proto())
                else:
                    out_list.append(e)
            out[key] = out_list
        elif isinstance(item, datetime):
            dt = timestamp_pb2.Timestamp()
            dt.FromDatetime(item)
            out[key] = dt
        elif isinstance(item, timedelta):
            td = duration_pb2.Duration()
            td.FromTimedelta(item)
            out[key] = td
        elif hasattr(item, "to_proto"):
            out[key] = item.to_proto()
        else:
            out[key] = item
    return out


def _set_attribute(
    attributes: dict, class_name: str, field: str, value: Any, fieldType: Any, oneOfField: str
):
    """Helper that sets attribute on the object.
    
    Accepts dicts for classes and normalizes enums.
    """
    if isinstance(value, dict) and getattr(fieldType, "__origin__", None) == dict:
        attributes[field] = value
    elif isinstance(value, dict):
        attributes[field] = fieldType(**value)
    elif isinstance(value, list):
        innerType = fieldType.__args__[0]
        if innerType in [str, float, bool]:
            attributes[field] = value
        elif innerType is int:
            attributes[field] = [int(x) for x in value]
        elif issubclass(innerType, Enum):
            if len(value) > 0:
                if isinstance(value[0], str):
                    attributes[field] = [innerType(x.upper()) for x in value]
                elif isinstance(value[0], int) and getattr(innerType, "from_proto", None) is not None:
                    attributes[field] = [innerType.from_proto(x) for x in value]
        else:
            attributes[field] = [innerType(**x) for x in value]
    elif isinstance(value, str) and issubclass(fieldType, Enum):
        attributes[field] = fieldType(value.upper())
    elif isinstance(value, int) and issubclass(fieldType, Enum) and getattr(fieldType, "from_proto", None) is not None:
        attributes[field] = fieldType.from_proto(value)
    elif isinstance(value, str) and fieldType == datetime:
        dt = timestamp_pb2.Timestamp()
        dt.FromJsonString(value)
        attributes[field] = dt.ToDatetime()
    elif isinstance(value, str) and fieldType == timedelta:
        td = timestamp_pb2.Duration()
        td.FromJsonString(value)
        attributes[field] = td.ToTimeDelta()
    elif isinstance(value, str) and fieldType == int:
        # Needed to handle int64 encoded as strings.
        attributes[field] = int(value)
    # Set zero values to be consistent with proto.
    elif value is None:
        if fieldType == str:
            attributes[field] = ""
        elif fieldType == int:
            attributes[field] = 0
        elif fieldType == float:
            attributes[field] = 0.0
        elif fieldType == bool:
            attributes[field] = False
        elif getattr(fieldType, "__origin__", None) == list:
            attributes[field] = []
        elif getattr(fieldType, "__origin__", None) == dict:
            attributes[field] = {}
        elif fieldType == datetime or fieldType == timedelta:
            attributes[field] = None
        else:
            if oneOfField == "":
                attributes[field] = fieldType()
            else:
                attributes[field] = None
    elif value is not None and not isinstance(value, fieldType):
        raise ValueError(
            f"'{class_name}.{field}' must have type {fieldType}, got {type(value)}"
        )
    else:
        attributes[field] = value


class Enum(enum.Enum):
    """Base enum class.
    
    Overrides equality to be case insentitive.
    """

    def __eq__(self, other) -> bool:
        """Object is equal with all types."""
        if isinstance(other, str):
            return self.name == other.upper()
        elif isinstance(other, int):
            return self.value == other
        else:
            return self.value == other.value
    
    def __str__(self) -> str:
        return self.value


class FieldType(Enum):
    """Featureset field types."""
    
    INVALID = "INVALID"
    NUMBER = "NUMBER"
    BOOLEAN = "BOOLEAN"
    CATEGORICAL = "CATEGORICAL"
    TEXT = "TEXT"
    TIMESTAMP = "TIMESTAMP"
    TIME = "TIME"
    DATE = "DATE"
    DATETIME = "DATETIME"
    NUMBER_LIST = "NUMBER_LIST"
    BOOLEAN_LIST = "BOOLEAN_LIST"
    TEXT_LIST = "TEXT_LIST"
    INDEX = "INDEX"
    TIME_INDEX = "TIME_INDEX"
    SPLIT = "SPLIT"

    @classmethod
    def from_proto(cls, value: int = 0) ->  FieldType:
        """Convert enum from proto representation."""
        return cls(management_types_pb2.FieldType.Name(value))

    def to_proto(self) -> int:
        """Convert enum to proto representation."""
        return management_types_pb2.FieldType.Value(self.value)

class BatchPredictionStoreType(Enum):
    """"""
    
    UNSPECIFIED = "UNSPECIFIED"
    CSV = "CSV"
    STORE = "STORE"

    @classmethod
    def from_proto(cls, value: int = 0) ->  BatchPredictionStoreType:
        """Convert enum from proto representation."""
        return cls(management_types_pb2.BatchPredictionStoreType.Name(value))

    def to_proto(self) -> int:
        """Convert enum to proto representation."""
        return management_types_pb2.BatchPredictionStoreType.Value(self.value)

class IngestionState(Enum):
    """"""
    
    STATE_UNSPECIFIED = "STATE_UNSPECIFIED"
    PENDING = "PENDING"
    RUNNING = "RUNNING"
    CANCELLING = "CANCELLING"
    SUCCEEDED = "SUCCEEDED"
    FAILED = "FAILED"
    CANCELLED = "CANCELLED"

    @classmethod
    def from_proto(cls, value: int = 0) ->  IngestionState:
        """Convert enum from proto representation."""
        return cls(management_types_pb2.Ingestion.State.Name(value))

    def to_proto(self) -> int:
        """Convert enum to proto representation."""
        return management_types_pb2.Ingestion.State.Value(self.value)

class OrganizationStatus(Enum):
    """"""
    
    EXPIRED = "EXPIRED"
    ACTIVE_TRIAL = "ACTIVE_TRIAL"
    ACTIVE = "ACTIVE"
    DISABLED = "DISABLED"

    @classmethod
    def from_proto(cls, value: int = 0) ->  OrganizationStatus:
        """Convert enum from proto representation."""
        return cls(management_types_pb2.Organization.Status.Name(value))

    def to_proto(self) -> int:
        """Convert enum to proto representation."""
        return management_types_pb2.Organization.Status.Value(self.value)

class ModelState(Enum):
    """"""
    
    HEALTHY = "HEALTHY"
    UNHEALTHY = "UNHEALTHY"
    OFFLINE = "OFFLINE"

    @classmethod
    def from_proto(cls, value: int = 0) ->  ModelState:
        """Convert enum from proto representation."""
        return cls(management_types_pb2.Model.State.Name(value))

    def to_proto(self) -> int:
        """Convert enum to proto representation."""
        return management_types_pb2.Model.State.Value(self.value)

class PromotionDecision(Enum):
    """"""
    
    DECISION_UNSPECIFIED = "DECISION_UNSPECIFIED"
    PROMOTE = "PROMOTE"
    NO_PROMOTE = "NO_PROMOTE"

    @classmethod
    def from_proto(cls, value: int = 0) ->  PromotionDecision:
        """Convert enum from proto representation."""
        return cls(management_types_pb2.Promotion.Decision.Name(value))

    def to_proto(self) -> int:
        """Convert enum to proto representation."""
        return management_types_pb2.Promotion.Decision.Value(self.value)

class PromotionReason(Enum):
    """"""
    
    REASON_UNSPECIFIED = "REASON_UNSPECIFIED"
    UPLIFT = "UPLIFT"
    NO_PROMOTED_MODEL_VERSION_EXISTS = "NO_PROMOTED_MODEL_VERSION_EXISTS"
    LATEST_POLICY = "LATEST_POLICY"
    UNDERPERFORMED = "UNDERPERFORMED"
    MANUAL = "MANUAL"
    FORCED = "FORCED"

    @classmethod
    def from_proto(cls, value: int = 0) ->  PromotionReason:
        """Convert enum from proto representation."""
        return cls(management_types_pb2.Promotion.Reason.Name(value))

    def to_proto(self) -> int:
        """Convert enum to proto representation."""
        return management_types_pb2.Promotion.Reason.Value(self.value)

class PromotionState(Enum):
    """"""
    
    STATE_UNSPECIFIED = "STATE_UNSPECIFIED"
    SUCCEEDED = "SUCCEEDED"
    FAILED = "FAILED"

    @classmethod
    def from_proto(cls, value: int = 0) ->  PromotionState:
        """Convert enum from proto representation."""
        return cls(management_types_pb2.Promotion.State.Name(value))

    def to_proto(self) -> int:
        """Convert enum to proto representation."""
        return management_types_pb2.Promotion.State.Value(self.value)

class ModelVersionState(Enum):
    """"""
    
    STATE_UNSPECIFIED = "STATE_UNSPECIFIED"
    CREATED = "CREATED"
    PENDING = "PENDING"
    PREPROCESSING = "PREPROCESSING"
    TRAINING = "TRAINING"
    POSTPROCESSING = "POSTPROCESSING"
    CANCELLING = "CANCELLING"
    SUCCEEDED = "SUCCEEDED"
    FAILED = "FAILED"
    CANCELLED = "CANCELLED"
    PROFILING = "PROFILING"

    @classmethod
    def from_proto(cls, value: int = 0) ->  ModelVersionState:
        """Convert enum from proto representation."""
        return cls(management_types_pb2.ModelVersion.State.Name(value))

    def to_proto(self) -> int:
        """Convert enum to proto representation."""
        return management_types_pb2.ModelVersion.State.Value(self.value)

class ExperimentState(Enum):
    """"""
    
    STATE_UNSPECIFIED = "STATE_UNSPECIFIED"
    PENDING = "PENDING"
    PREPROCESSING = "PREPROCESSING"
    TRAINING = "TRAINING"
    POSTPROCESSING = "POSTPROCESSING"
    CANCELLING = "CANCELLING"
    SUCCEEDED = "SUCCEEDED"
    FAILED = "FAILED"
    CANCELLED = "CANCELLED"

    @classmethod
    def from_proto(cls, value: int = 0) ->  ExperimentState:
        """Convert enum from proto representation."""
        return cls(management_types_pb2.Experiment.State.Name(value))

    def to_proto(self) -> int:
        """Convert enum to proto representation."""
        return management_types_pb2.Experiment.State.Value(self.value)

class ChangeState(Enum):
    """"""
    
    STATE_UNSPECIFIED = "STATE_UNSPECIFIED"
    PENDING = "PENDING"
    EXECUTING = "EXECUTING"
    CANCELLING = "CANCELLING"
    SUCCEEDED = "SUCCEEDED"
    FAILED = "FAILED"
    CANCELLED = "CANCELLED"

    @classmethod
    def from_proto(cls, value: int = 0) ->  ChangeState:
        """Convert enum from proto representation."""
        return cls(management_types_pb2.Change.State.Name(value))

    def to_proto(self) -> int:
        """Convert enum to proto representation."""
        return management_types_pb2.Change.State.Value(self.value)

class PlanStepState(Enum):
    """"""
    
    STATE_UNSPECIFIED = "STATE_UNSPECIFIED"
    PENDING = "PENDING"
    EXECUTING = "EXECUTING"
    SUCCEEDED = "SUCCEEDED"
    FAILED = "FAILED"
    CANCELLED = "CANCELLED"
    CANCELLING = "CANCELLING"
    SKIPPED = "SKIPPED"

    @classmethod
    def from_proto(cls, value: int = 0) ->  PlanStepState:
        """Convert enum from proto representation."""
        return cls(management_types_pb2.PlanStep.State.Name(value))

    def to_proto(self) -> int:
        """Convert enum to proto representation."""
        return management_types_pb2.PlanStep.State.Value(self.value)

class PlanStepOperation(Enum):
    """"""
    
    OPERATION_UNSPECIFICIED = "OPERATION_UNSPECIFICIED"
    PUT = "PUT"
    DELETE = "DELETE"
    INGEST = "INGEST"
    TRAIN = "TRAIN"
    PROMOTE = "PROMOTE"
    PROFILE = "PROFILE"
    BATCHPREDICT = "BATCHPREDICT"
    CREATE = "CREATE"
    UPDATE = "UPDATE"
    PREDICT = "PREDICT"

    @classmethod
    def from_proto(cls, value: int = 0) ->  PlanStepOperation:
        """Convert enum from proto representation."""
        return cls(management_types_pb2.PlanStep.Operation.Name(value))

    def to_proto(self) -> int:
        """Convert enum to proto representation."""
        return management_types_pb2.PlanStep.Operation.Value(self.value)

class PlanStepType(Enum):
    """"""
    
    TYPE_UNSPECIFIED = "TYPE_UNSPECIFIED"
    CREATE_FEATURE_SET = "CREATE_FEATURE_SET"
    UPDATE_FEATURE_SET = "UPDATE_FEATURE_SET"
    PROFILE_FEATURE_SET = "PROFILE_FEATURE_SET"
    DELETE_FEATURE_SET = "DELETE_FEATURE_SET"
    CREATE_MODEL = "CREATE_MODEL"
    UPDATE_MODEL = "UPDATE_MODEL"
    PROFILE_MODEL = "PROFILE_MODEL"
    DELETE_MODEL = "DELETE_MODEL"
    TRAIN_MODEL = "TRAIN_MODEL"
    PROMOTE_MODEL = "PROMOTE_MODEL"
    PREDICT_MODEL = "PREDICT_MODEL"

    @classmethod
    def from_proto(cls, value: int = 0) ->  PlanStepType:
        """Convert enum from proto representation."""
        return cls(management_types_pb2.PlanStep.Type.Name(value))

    def to_proto(self) -> int:
        """Convert enum to proto representation."""
        return management_types_pb2.PlanStep.Type.Value(self.value)

class PlanStepUpdateModelUpdateType(Enum):
    """"""
    
    UNKNOWN = "UNKNOWN"
    DESCRIPTION = "DESCRIPTION"
    DOCUMENTATION = "DOCUMENTATION"
    QUERY = "QUERY"
    TABLE = "TABLE"
    INDEX = "INDEX"
    TIME_INDEX = "TIME_INDEX"
    SPLIT = "SPLIT"
    EXCLUDE_COLUMNS = "EXCLUDE_COLUMNS"
    PROFILE_CONFIG = "PROFILE_CONFIG"
    TRAINING_CONFIG = "TRAINING_CONFIG"
    PROMOTION_CONFIG = "PROMOTION_CONFIG"
    PREDICTION_CONFIG = "PREDICTION_CONFIG"

    @classmethod
    def from_proto(cls, value: int = 0) ->  PlanStepUpdateModelUpdateType:
        """Convert enum from proto representation."""
        return cls(management_types_pb2.PlanStep.UpdateModel.UpdateType.Name(value))

    def to_proto(self) -> int:
        """Convert enum to proto representation."""
        return management_types_pb2.PlanStep.UpdateModel.UpdateType.Value(self.value)

class PlanStepUpdateFeatureSetUpdateType(Enum):
    """"""
    
    UNKNOWN = "UNKNOWN"
    DESCRIPTION = "DESCRIPTION"
    DOCUMENTATION = "DOCUMENTATION"
    QUERY = "QUERY"
    TABLE = "TABLE"
    ENTITY = "ENTITY"
    INDEX = "INDEX"
    TIME_INDEX = "TIME_INDEX"
    SPLIT = "SPLIT"
    EXCLUDE_COLUMNS = "EXCLUDE_COLUMNS"
    PROFILE_CONFIG = "PROFILE_CONFIG"

    @classmethod
    def from_proto(cls, value: int = 0) ->  PlanStepUpdateFeatureSetUpdateType:
        """Convert enum from proto representation."""
        return cls(management_types_pb2.PlanStep.UpdateFeatureSet.UpdateType.Name(value))

    def to_proto(self) -> int:
        """Convert enum to proto representation."""
        return management_types_pb2.PlanStep.UpdateFeatureSet.UpdateType.Value(self.value)

class PlanStepTrainBaseModelVersionType(Enum):
    """"""
    
    BASE_MODEL_VERSION_TYPE_UNSPECIFIED = "BASE_MODEL_VERSION_TYPE_UNSPECIFIED"
    PROMOTED = "PROMOTED"
    LATEST = "LATEST"
    PRODUCTION = "PRODUCTION"

    @classmethod
    def from_proto(cls, value: int = 0) ->  PlanStepTrainBaseModelVersionType:
        """Convert enum from proto representation."""
        return cls(management_types_pb2.PlanStep.Train.BaseModelVersionType.Name(value))

    def to_proto(self) -> int:
        """Convert enum to proto representation."""
        return management_types_pb2.PlanStep.Train.BaseModelVersionType.Value(self.value)

class PlanStepTrainReason(Enum):
    """"""
    
    REASON_UNSPECIFIED = "REASON_UNSPECIFIED"
    DATA_CHANGED = "DATA_CHANGED"
    FORCED = "FORCED"

    @classmethod
    def from_proto(cls, value: int = 0) ->  PlanStepTrainReason:
        """Convert enum from proto representation."""
        return cls(management_types_pb2.PlanStep.Train.Reason.Name(value))

    def to_proto(self) -> int:
        """Convert enum to proto representation."""
        return management_types_pb2.PlanStep.Train.Reason.Value(self.value)

class BatchPredictionState(Enum):
    """"""
    
    STATE_UNSPECIFIED = "STATE_UNSPECIFIED"
    CREATED = "CREATED"
    PENDING = "PENDING"
    PREPROCESSING = "PREPROCESSING"
    PROCESSING = "PROCESSING"
    POSTPROCESSING = "POSTPROCESSING"
    CANCELLING = "CANCELLING"
    SUCCEEDED = "SUCCEEDED"
    FAILED = "FAILED"
    CANCELLED = "CANCELLED"

    @classmethod
    def from_proto(cls, value: int = 0) ->  BatchPredictionState:
        """Convert enum from proto representation."""
        return cls(management_types_pb2.BatchPrediction.State.Name(value))

    def to_proto(self) -> int:
        """Convert enum to proto representation."""
        return management_types_pb2.BatchPrediction.State.Value(self.value)

class BrowseDataWarehouseRequestObjectType(Enum):
    """"""
    
    DATABASE = "DATABASE"
    SCHEMA = "SCHEMA"
    TABLE = "TABLE"
    COLUMN = "COLUMN"

    @classmethod
    def from_proto(cls, value: int = 0) ->  BrowseDataWarehouseRequestObjectType:
        """Convert enum from proto representation."""
        return cls(management_pb2.BrowseDataWarehouseRequest.ObjectType.Name(value))

    def to_proto(self) -> int:
        """Convert enum to proto representation."""
        return management_pb2.BrowseDataWarehouseRequest.ObjectType.Value(self.value)



class IngestionErrorDetail:
    """INGESTIONS"""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , description: str = ""
        , count: int = 0
    , **kwargs) -> IngestionErrorDetail:
        self._attributes = dict()
        self.description = description
        self.count = count

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def description(self) -> str:
        """user friendly error message of the error."""
        return self._attributes["description"]


    @description.setter
    def description(self, value: str) -> None:
        _set_attribute(self._attributes, "IngestionErrorDetail", "description", value, str, "")


    @property
    def count(self) -> int:
        """Count of rows having this error."""
        return self._attributes["count"]


    @count.setter
    def count(self, value: int) -> None:
        _set_attribute(self._attributes, "IngestionErrorDetail", "count", value, int, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.IngestionErrorDetail, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.IngestionErrorDetail:
        """Convert object to proto representation."""
        return management_types_pb2.IngestionErrorDetail(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<IngestionErrorDetail object " + repr(self.to_dict()) + ">"


class Ingestion:
    """Ingestion."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , state: IngestionState = 0
        , ingested_row_count: int = 0
        , ingested_bytes: int = 0
        , error_details: List[IngestionErrorDetail] = []
        , create_time: datetime = None
        , start_time: datetime = None
        , finish_time: datetime = None
    , **kwargs) -> Ingestion:
        self._attributes = dict()
        self.name = name
        self.state = state
        self.ingested_row_count = ingested_row_count
        self.ingested_bytes = ingested_bytes
        self.error_details = error_details
        self.create_time = create_time
        self.start_time = start_time
        self.finish_time = finish_time

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """name =
 projects/:project/featuresets/:featureset[@:version]/ingestions/:ingestion"""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "Ingestion", "name", value, str, "")


    @property
    def state(self) -> IngestionState:
        """Current state of job."""
        return self._attributes["state"]


    @state.setter
    def state(self, value: IngestionState) -> None:
        _set_attribute(self._attributes, "Ingestion", "state", value, IngestionState, "")


    @property
    def ingested_row_count(self) -> int:
        """Number of rows ingested (could be realtime)"""
        return self._attributes["ingested_row_count"]


    @ingested_row_count.setter
    def ingested_row_count(self, value: int) -> None:
        _set_attribute(self._attributes, "Ingestion", "ingested_row_count", value, int, "")


    @property
    def ingested_bytes(self) -> int:
        """Number of bytes ingested (could be realtime)"""
        return self._attributes["ingested_bytes"]


    @ingested_bytes.setter
    def ingested_bytes(self, value: int) -> None:
        _set_attribute(self._attributes, "Ingestion", "ingested_bytes", value, int, "")


    @property
    def error_details(self) -> List[IngestionErrorDetail]:
        """Details of the errors."""
        return self._attributes["error_details"]


    @error_details.setter
    def error_details(self, value: List[IngestionErrorDetail]) -> None:
        _set_attribute(self._attributes, "Ingestion", "error_details", value, List[IngestionErrorDetail], "")


    @property
    def create_time(self) -> datetime:
        """Ingestion create time."""
        return self._attributes["create_time"]


    @create_time.setter
    def create_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Ingestion", "create_time", value, datetime, "")


    @property
    def start_time(self) -> datetime:
        """Ingestion start time."""
        return self._attributes["start_time"]


    @start_time.setter
    def start_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Ingestion", "start_time", value, datetime, "")


    @property
    def finish_time(self) -> datetime:
        """Ingestion finish time."""
        return self._attributes["finish_time"]


    @finish_time.setter
    def finish_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Ingestion", "finish_time", value, datetime, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.Ingestion, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.Ingestion:
        """Convert object to proto representation."""
        return management_types_pb2.Ingestion(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<Ingestion object " + repr(self.to_dict()) + ">"


class User:
    """User."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , email: str = ""
        , email_verified: bool = False
        , full_name: str = ""
        , bio: str = ""
        , location: str = ""
        , password: str = ""
        , service_account: bool = False
        , update_time: datetime = None
        , create_time: datetime = None
        , disabled: bool = False
        , trial_available: bool = False
        , first_name: str = ""
        , last_name: str = ""
    , **kwargs) -> User:
        self._attributes = dict()
        self.name = name
        self.email = email
        self.email_verified = email_verified
        self.full_name = full_name
        self.bio = bio
        self.location = location
        self.password = password
        self.service_account = service_account
        self.update_time = update_time
        self.create_time = create_time
        self.disabled = disabled
        self.trial_available = trial_available
        self.first_name = first_name
        self.last_name = last_name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "User", "name", value, str, "")


    @property
    def email(self) -> str:
        """Email."""
        return self._attributes["email"]


    @email.setter
    def email(self, value: str) -> None:
        _set_attribute(self._attributes, "User", "email", value, str, "")


    @property
    def email_verified(self) -> bool:
        """Email verified."""
        return self._attributes["email_verified"]


    @email_verified.setter
    def email_verified(self, value: bool) -> None:
        _set_attribute(self._attributes, "User", "email_verified", value, bool, "")


    @property
    def full_name(self) -> str:
        """Full name."""
        return self._attributes["full_name"]


    @full_name.setter
    def full_name(self, value: str) -> None:
        _set_attribute(self._attributes, "User", "full_name", value, str, "")


    @property
    def bio(self) -> str:
        """Bio."""
        return self._attributes["bio"]


    @bio.setter
    def bio(self, value: str) -> None:
        _set_attribute(self._attributes, "User", "bio", value, str, "")


    @property
    def location(self) -> str:
        """Location."""
        return self._attributes["location"]


    @location.setter
    def location(self, value: str) -> None:
        _set_attribute(self._attributes, "User", "location", value, str, "")


    @property
    def password(self) -> str:
        """Password."""
        return self._attributes["password"]


    @password.setter
    def password(self, value: str) -> None:
        _set_attribute(self._attributes, "User", "password", value, str, "")


    @property
    def service_account(self) -> bool:
        """Service account."""
        return self._attributes["service_account"]


    @service_account.setter
    def service_account(self, value: bool) -> None:
        _set_attribute(self._attributes, "User", "service_account", value, bool, "")


    @property
    def update_time(self) -> datetime:
        """Update time."""
        return self._attributes["update_time"]


    @update_time.setter
    def update_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "User", "update_time", value, datetime, "")


    @property
    def create_time(self) -> datetime:
        """Create time."""
        return self._attributes["create_time"]


    @create_time.setter
    def create_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "User", "create_time", value, datetime, "")


    @property
    def disabled(self) -> bool:
        """Disabled."""
        return self._attributes["disabled"]


    @disabled.setter
    def disabled(self, value: bool) -> None:
        _set_attribute(self._attributes, "User", "disabled", value, bool, "")


    @property
    def trial_available(self) -> bool:
        """Trial available."""
        return self._attributes["trial_available"]


    @trial_available.setter
    def trial_available(self, value: bool) -> None:
        _set_attribute(self._attributes, "User", "trial_available", value, bool, "")


    @property
    def first_name(self) -> str:
        """First name."""
        return self._attributes["first_name"]


    @first_name.setter
    def first_name(self, value: str) -> None:
        _set_attribute(self._attributes, "User", "first_name", value, str, "")


    @property
    def last_name(self) -> str:
        """Last name."""
        return self._attributes["last_name"]


    @last_name.setter
    def last_name(self, value: str) -> None:
        _set_attribute(self._attributes, "User", "last_name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.User, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.User:
        """Convert object to proto representation."""
        return management_types_pb2.User(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<User object " + repr(self.to_dict()) + ">"


class Session:
    """Session."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , subject: str = ""
        , last_access_ip: str = ""
        , last_access_time: datetime = None
        , login_ip: str = ""
        , login_time: datetime = None
        , login_user_agent: str = ""
    , **kwargs) -> Session:
        self._attributes = dict()
        self.name = name
        self.subject = subject
        self.last_access_ip = last_access_ip
        self.last_access_time = last_access_time
        self.login_ip = login_ip
        self.login_time = login_time
        self.login_user_agent = login_user_agent

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "Session", "name", value, str, "")


    @property
    def subject(self) -> str:
        """Subject."""
        return self._attributes["subject"]


    @subject.setter
    def subject(self, value: str) -> None:
        _set_attribute(self._attributes, "Session", "subject", value, str, "")


    @property
    def last_access_ip(self) -> str:
        """Last access ip."""
        return self._attributes["last_access_ip"]


    @last_access_ip.setter
    def last_access_ip(self, value: str) -> None:
        _set_attribute(self._attributes, "Session", "last_access_ip", value, str, "")


    @property
    def last_access_time(self) -> datetime:
        """Last access time."""
        return self._attributes["last_access_time"]


    @last_access_time.setter
    def last_access_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Session", "last_access_time", value, datetime, "")


    @property
    def login_ip(self) -> str:
        """Login ip."""
        return self._attributes["login_ip"]


    @login_ip.setter
    def login_ip(self, value: str) -> None:
        _set_attribute(self._attributes, "Session", "login_ip", value, str, "")


    @property
    def login_time(self) -> datetime:
        """Login time."""
        return self._attributes["login_time"]


    @login_time.setter
    def login_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Session", "login_time", value, datetime, "")


    @property
    def login_user_agent(self) -> str:
        """Login user agent."""
        return self._attributes["login_user_agent"]


    @login_user_agent.setter
    def login_user_agent(self, value: str) -> None:
        _set_attribute(self._attributes, "Session", "login_user_agent", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.Session, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.Session:
        """Convert object to proto representation."""
        return management_types_pb2.Session(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<Session object " + repr(self.to_dict()) + ">"


class Role:
    """A access control role."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , title: str = ""
        , description: str = ""
        , resource_type: str = ""
        , permissions: List[str] = []
    , **kwargs) -> Role:
        self._attributes = dict()
        self.name = name
        self.title = title
        self.description = description
        self.resource_type = resource_type
        self.permissions = permissions

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """The name of the role."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "Role", "name", value, str, "")


    @property
    def title(self) -> str:
        """A human-readable title for the role."""
        return self._attributes["title"]


    @title.setter
    def title(self, value: str) -> None:
        _set_attribute(self._attributes, "Role", "title", value, str, "")


    @property
    def description(self) -> str:
        """A human-readable description for the role."""
        return self._attributes["description"]


    @description.setter
    def description(self, value: str) -> None:
        _set_attribute(self._attributes, "Role", "description", value, str, "")


    @property
    def resource_type(self) -> str:
        """Resource type that role can be assigned."""
        return self._attributes["resource_type"]


    @resource_type.setter
    def resource_type(self, value: str) -> None:
        _set_attribute(self._attributes, "Role", "resource_type", value, str, "")


    @property
    def permissions(self) -> List[str]:
        """The names of the permissions this role grants."""
        return self._attributes["permissions"]


    @permissions.setter
    def permissions(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "Role", "permissions", value, List[str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.Role, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.Role:
        """Convert object to proto representation."""
        return management_types_pb2.Role(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<Role object " + repr(self.to_dict()) + ">"


class AccessPolicy:
    """AccessPolicy grants a role between a subject and a resource.
 Subjects can be users or service accounts and resources
 can currently be organizations or projects.  Subjects can have
 multiple roles assigned to them."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , subject: str = ""
        , resource: str = ""
        , role: str = ""
        , create_time: datetime = None
    , **kwargs) -> AccessPolicy:
        self._attributes = dict()
        self.name = name
        self.subject = subject
        self.resource = resource
        self.role = role
        self.create_time = create_time

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """The name of the role grant."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "AccessPolicy", "name", value, str, "")


    @property
    def subject(self) -> str:
        """The subject of the role grant, either a user, group, or service account."""
        return self._attributes["subject"]


    @subject.setter
    def subject(self, value: str) -> None:
        _set_attribute(self._attributes, "AccessPolicy", "subject", value, str, "")


    @property
    def resource(self) -> str:
        """The resource on which the role is granted."""
        return self._attributes["resource"]


    @resource.setter
    def resource(self, value: str) -> None:
        _set_attribute(self._attributes, "AccessPolicy", "resource", value, str, "")


    @property
    def role(self) -> str:
        """the role being granted, such as roles/project.viewer"""
        return self._attributes["role"]


    @role.setter
    def role(self, value: str) -> None:
        _set_attribute(self._attributes, "AccessPolicy", "role", value, str, "")


    @property
    def create_time(self) -> datetime:
        """The date the role was created."""
        return self._attributes["create_time"]


    @create_time.setter
    def create_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "AccessPolicy", "create_time", value, datetime, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.AccessPolicy, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.AccessPolicy:
        """Convert object to proto representation."""
        return management_types_pb2.AccessPolicy(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<AccessPolicy object " + repr(self.to_dict()) + ">"


class Invite:
    """Project or organization invitation."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , sender: str = ""
        , email: str = ""
        , role: str = ""
        , create_time: datetime = None
        , expire_time: datetime = None
    , **kwargs) -> Invite:
        self._attributes = dict()
        self.name = name
        self.sender = sender
        self.email = email
        self.role = role
        self.create_time = create_time
        self.expire_time = expire_time

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Invite name"""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "Invite", "name", value, str, "")


    @property
    def sender(self) -> str:
        """Sender"""
        return self._attributes["sender"]


    @sender.setter
    def sender(self, value: str) -> None:
        _set_attribute(self._attributes, "Invite", "sender", value, str, "")


    @property
    def email(self) -> str:
        """User email"""
        return self._attributes["email"]


    @email.setter
    def email(self, value: str) -> None:
        _set_attribute(self._attributes, "Invite", "email", value, str, "")


    @property
    def role(self) -> str:
        """Invite role."""
        return self._attributes["role"]


    @role.setter
    def role(self, value: str) -> None:
        _set_attribute(self._attributes, "Invite", "role", value, str, "")


    @property
    def create_time(self) -> datetime:
        """Invite create time."""
        return self._attributes["create_time"]


    @create_time.setter
    def create_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Invite", "create_time", value, datetime, "")


    @property
    def expire_time(self) -> datetime:
        """Invite expire time."""
        return self._attributes["expire_time"]


    @expire_time.setter
    def expire_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Invite", "expire_time", value, datetime, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.Invite, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.Invite:
        """Convert object to proto representation."""
        return management_types_pb2.Invite(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<Invite object " + repr(self.to_dict()) + ">"


class Organization:
    """Organization."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , display_name: str = ""
        , update_time: datetime = None
        , create_time: datetime = None
        , status: OrganizationStatus = 0
        , trial_end_date: datetime = None
        , trial_credits: int = 0
        , trial_credits_used: int = 0
        , show_plan: bool = False
    , **kwargs) -> Organization:
        self._attributes = dict()
        self.name = name
        self.display_name = display_name
        self.update_time = update_time
        self.create_time = create_time
        self.status = status
        self.trial_end_date = trial_end_date
        self.trial_credits = trial_credits
        self.trial_credits_used = trial_credits_used
        self.show_plan = show_plan

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "Organization", "name", value, str, "")


    @property
    def display_name(self) -> str:
        """Display name."""
        return self._attributes["display_name"]


    @display_name.setter
    def display_name(self, value: str) -> None:
        _set_attribute(self._attributes, "Organization", "display_name", value, str, "")


    @property
    def update_time(self) -> datetime:
        """Update time."""
        return self._attributes["update_time"]


    @update_time.setter
    def update_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Organization", "update_time", value, datetime, "")


    @property
    def create_time(self) -> datetime:
        """Create time."""
        return self._attributes["create_time"]


    @create_time.setter
    def create_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Organization", "create_time", value, datetime, "")


    @property
    def status(self) -> OrganizationStatus:
        """Status."""
        return self._attributes["status"]


    @status.setter
    def status(self, value: OrganizationStatus) -> None:
        _set_attribute(self._attributes, "Organization", "status", value, OrganizationStatus, "")


    @property
    def trial_end_date(self) -> datetime:
        """Trial end date."""
        return self._attributes["trial_end_date"]


    @trial_end_date.setter
    def trial_end_date(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Organization", "trial_end_date", value, datetime, "")


    @property
    def trial_credits(self) -> int:
        """Trial credits."""
        return self._attributes["trial_credits"]


    @trial_credits.setter
    def trial_credits(self, value: int) -> None:
        _set_attribute(self._attributes, "Organization", "trial_credits", value, int, "")


    @property
    def trial_credits_used(self) -> int:
        """Trial credits used."""
        return self._attributes["trial_credits_used"]


    @trial_credits_used.setter
    def trial_credits_used(self, value: int) -> None:
        _set_attribute(self._attributes, "Organization", "trial_credits_used", value, int, "")


    @property
    def show_plan(self) -> bool:
        """Show plan."""
        return self._attributes["show_plan"]


    @show_plan.setter
    def show_plan(self, value: bool) -> None:
        _set_attribute(self._attributes, "Organization", "show_plan", value, bool, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.Organization, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.Organization:
        """Convert object to proto representation."""
        return management_types_pb2.Organization(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<Organization object " + repr(self.to_dict()) + ">"


class Onboarding:
    """Onboarding."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , create_time: datetime = None
        , update_time: datetime = None
        , project_created: bool = False
        , model_created: bool = False
        , feature_set_created: bool = False
        , billing_setup: bool = False
        , dismissed: bool = False
    , **kwargs) -> Onboarding:
        self._attributes = dict()
        self.name = name
        self.create_time = create_time
        self.update_time = update_time
        self.project_created = project_created
        self.model_created = model_created
        self.feature_set_created = feature_set_created
        self.billing_setup = billing_setup
        self.dismissed = dismissed

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "Onboarding", "name", value, str, "")


    @property
    def create_time(self) -> datetime:
        """Create time."""
        return self._attributes["create_time"]


    @create_time.setter
    def create_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Onboarding", "create_time", value, datetime, "")


    @property
    def update_time(self) -> datetime:
        """Update time."""
        return self._attributes["update_time"]


    @update_time.setter
    def update_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Onboarding", "update_time", value, datetime, "")


    @property
    def project_created(self) -> bool:
        """Project created."""
        return self._attributes["project_created"]


    @project_created.setter
    def project_created(self, value: bool) -> None:
        _set_attribute(self._attributes, "Onboarding", "project_created", value, bool, "")


    @property
    def model_created(self) -> bool:
        """Model created."""
        return self._attributes["model_created"]


    @model_created.setter
    def model_created(self, value: bool) -> None:
        _set_attribute(self._attributes, "Onboarding", "model_created", value, bool, "")


    @property
    def feature_set_created(self) -> bool:
        """Feature set created."""
        return self._attributes["feature_set_created"]


    @feature_set_created.setter
    def feature_set_created(self, value: bool) -> None:
        _set_attribute(self._attributes, "Onboarding", "feature_set_created", value, bool, "")


    @property
    def billing_setup(self) -> bool:
        """Billing setup."""
        return self._attributes["billing_setup"]


    @billing_setup.setter
    def billing_setup(self, value: bool) -> None:
        _set_attribute(self._attributes, "Onboarding", "billing_setup", value, bool, "")


    @property
    def dismissed(self) -> bool:
        """Dismissed."""
        return self._attributes["dismissed"]


    @dismissed.setter
    def dismissed(self, value: bool) -> None:
        _set_attribute(self._attributes, "Onboarding", "dismissed", value, bool, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.Onboarding, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.Onboarding:
        """Convert object to proto representation."""
        return management_types_pb2.Onboarding(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<Onboarding object " + repr(self.to_dict()) + ">"


class Project:
    """Project."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , display_name: str = ""
        , organization: str = ""
        , summary: ProjectSummary = None
        , data_store: DataStore = None
        , update_time: datetime = None
        , create_time: datetime = None
    , **kwargs) -> Project:
        self._attributes = dict()
        self.name = name
        self.display_name = display_name
        self.organization = organization
        self.summary = summary
        self.data_store = data_store
        self.update_time = update_time
        self.create_time = create_time

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """/ Project resource name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "Project", "name", value, str, "")


    @property
    def display_name(self) -> str:
        """/ Display name."""
        return self._attributes["display_name"]


    @display_name.setter
    def display_name(self, value: str) -> None:
        _set_attribute(self._attributes, "Project", "display_name", value, str, "")


    @property
    def organization(self) -> str:
        """Organization."""
        return self._attributes["organization"]


    @organization.setter
    def organization(self, value: str) -> None:
        _set_attribute(self._attributes, "Project", "organization", value, str, "")


    @property
    def summary(self) -> ProjectSummary:
        """Summary."""
        return self._attributes["summary"]


    @summary.setter
    def summary(self, value: ProjectSummary) -> None:
        _set_attribute(self._attributes, "Project", "summary", value, ProjectSummary, "")


    @property
    def data_store(self) -> DataStore:
        """Data store."""
        return self._attributes["data_store"]


    @data_store.setter
    def data_store(self, value: DataStore) -> None:
        _set_attribute(self._attributes, "Project", "data_store", value, DataStore, "")


    @property
    def update_time(self) -> datetime:
        """Update time."""
        return self._attributes["update_time"]


    @update_time.setter
    def update_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Project", "update_time", value, datetime, "")


    @property
    def create_time(self) -> datetime:
        """Create time."""
        return self._attributes["create_time"]


    @create_time.setter
    def create_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Project", "create_time", value, datetime, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.Project, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.Project:
        """Convert object to proto representation."""
        return management_types_pb2.Project(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<Project object " + repr(self.to_dict()) + ">"


class ProjectSummary:
    """Project summary statistics."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , feature_set_count: int = 0
        , feature_set_row_count: int = 0
        , feature_set_bytes: int = 0
        , feature_count: int = 0
        , connection_count: int = 0
        , model_count: int = 0
        , model_version_count: int = 0
        , experiment_count: int = 0
        , prediction_count: int = 0
        , feature_set_health: HealthCounts = None
        , model_health: HealthCounts = None
        , last_ingestion_time: datetime = None
        , last_deployment_time: datetime = None
        , last_training_time: datetime = None
    , **kwargs) -> ProjectSummary:
        self._attributes = dict()
        self.feature_set_count = feature_set_count
        self.feature_set_row_count = feature_set_row_count
        self.feature_set_bytes = feature_set_bytes
        self.feature_count = feature_count
        self.connection_count = connection_count
        self.model_count = model_count
        self.model_version_count = model_version_count
        self.experiment_count = experiment_count
        self.prediction_count = prediction_count
        self.feature_set_health = feature_set_health
        self.model_health = model_health
        self.last_ingestion_time = last_ingestion_time
        self.last_deployment_time = last_deployment_time
        self.last_training_time = last_training_time

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def feature_set_count(self) -> int:
        """Total number of feature sets."""
        return self._attributes["feature_set_count"]


    @feature_set_count.setter
    def feature_set_count(self, value: int) -> None:
        _set_attribute(self._attributes, "ProjectSummary", "feature_set_count", value, int, "")


    @property
    def feature_set_row_count(self) -> int:
        """Total number of feature rows."""
        return self._attributes["feature_set_row_count"]


    @feature_set_row_count.setter
    def feature_set_row_count(self, value: int) -> None:
        _set_attribute(self._attributes, "ProjectSummary", "feature_set_row_count", value, int, "")


    @property
    def feature_set_bytes(self) -> int:
        """Featureset total number of bytes."""
        return self._attributes["feature_set_bytes"]


    @feature_set_bytes.setter
    def feature_set_bytes(self, value: int) -> None:
        _set_attribute(self._attributes, "ProjectSummary", "feature_set_bytes", value, int, "")


    @property
    def feature_count(self) -> int:
        """Total number of unique features."""
        return self._attributes["feature_count"]


    @feature_count.setter
    def feature_count(self, value: int) -> None:
        _set_attribute(self._attributes, "ProjectSummary", "feature_count", value, int, "")


    @property
    def connection_count(self) -> int:
        """Total number of connections."""
        return self._attributes["connection_count"]


    @connection_count.setter
    def connection_count(self, value: int) -> None:
        _set_attribute(self._attributes, "ProjectSummary", "connection_count", value, int, "")


    @property
    def model_count(self) -> int:
        """Total number of models."""
        return self._attributes["model_count"]


    @model_count.setter
    def model_count(self, value: int) -> None:
        _set_attribute(self._attributes, "ProjectSummary", "model_count", value, int, "")


    @property
    def model_version_count(self) -> int:
        """Total number modelVersions."""
        return self._attributes["model_version_count"]


    @model_version_count.setter
    def model_version_count(self, value: int) -> None:
        _set_attribute(self._attributes, "ProjectSummary", "model_version_count", value, int, "")


    @property
    def experiment_count(self) -> int:
        """Total number experiments."""
        return self._attributes["experiment_count"]


    @experiment_count.setter
    def experiment_count(self, value: int) -> None:
        _set_attribute(self._attributes, "ProjectSummary", "experiment_count", value, int, "")


    @property
    def prediction_count(self) -> int:
        """Total number of predictions."""
        return self._attributes["prediction_count"]


    @prediction_count.setter
    def prediction_count(self, value: int) -> None:
        _set_attribute(self._attributes, "ProjectSummary", "prediction_count", value, int, "")


    @property
    def feature_set_health(self) -> HealthCounts:
        """Feature set health."""
        return self._attributes["feature_set_health"]


    @feature_set_health.setter
    def feature_set_health(self, value: HealthCounts) -> None:
        _set_attribute(self._attributes, "ProjectSummary", "feature_set_health", value, HealthCounts, "")


    @property
    def model_health(self) -> HealthCounts:
        """Model health."""
        return self._attributes["model_health"]


    @model_health.setter
    def model_health(self, value: HealthCounts) -> None:
        _set_attribute(self._attributes, "ProjectSummary", "model_health", value, HealthCounts, "")


    @property
    def last_ingestion_time(self) -> datetime:
        """Last ingestion."""
        return self._attributes["last_ingestion_time"]


    @last_ingestion_time.setter
    def last_ingestion_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ProjectSummary", "last_ingestion_time", value, datetime, "")


    @property
    def last_deployment_time(self) -> datetime:
        """Last deployment"""
        return self._attributes["last_deployment_time"]


    @last_deployment_time.setter
    def last_deployment_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ProjectSummary", "last_deployment_time", value, datetime, "")


    @property
    def last_training_time(self) -> datetime:
        """Last training"""
        return self._attributes["last_training_time"]


    @last_training_time.setter
    def last_training_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ProjectSummary", "last_training_time", value, datetime, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.ProjectSummary, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.ProjectSummary:
        """Convert object to proto representation."""
        return management_types_pb2.ProjectSummary(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ProjectSummary object " + repr(self.to_dict()) + ">"


class DataStore:
    """Datastore for feature store."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , type: str = ""
        , big_query: DataStoreBigQuery = None
        , snowflake: DataStoreSnowflake = None
        , postgres: DataStorePostgres = None
        , redshift: DataStoreRedshift = None
        , databricks: DataStoreDatabricks = None
        , is_demo_data_store: bool = False
    , **kwargs) -> DataStore:
        self._attributes = dict()
        self.type = type
        self.big_query = big_query
        self.snowflake = snowflake
        self.postgres = postgres
        self.redshift = redshift
        self.databricks = databricks
        self.is_demo_data_store = is_demo_data_store

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def type(self) -> str:
        """Type of connection. Eg. snowflake, continual"""
        return self._attributes["type"]


    @type.setter
    def type(self, value: str) -> None:
        _set_attribute(self._attributes, "DataStore", "type", value, str, "")


    @property
    def big_query(self) -> DataStoreBigQuery:
        """Big query."""
        return self._attributes["big_query"]


    @big_query.setter
    def big_query(self, value: DataStoreBigQuery) -> None:
        _set_attribute(self._attributes, "DataStore", "big_query", value, DataStoreBigQuery, "config")


    @property
    def snowflake(self) -> DataStoreSnowflake:
        """Snowflake."""
        return self._attributes["snowflake"]


    @snowflake.setter
    def snowflake(self, value: DataStoreSnowflake) -> None:
        _set_attribute(self._attributes, "DataStore", "snowflake", value, DataStoreSnowflake, "config")


    @property
    def postgres(self) -> DataStorePostgres:
        """Postgres."""
        return self._attributes["postgres"]


    @postgres.setter
    def postgres(self, value: DataStorePostgres) -> None:
        _set_attribute(self._attributes, "DataStore", "postgres", value, DataStorePostgres, "config")


    @property
    def redshift(self) -> DataStoreRedshift:
        """Redshift."""
        return self._attributes["redshift"]


    @redshift.setter
    def redshift(self, value: DataStoreRedshift) -> None:
        _set_attribute(self._attributes, "DataStore", "redshift", value, DataStoreRedshift, "config")


    @property
    def databricks(self) -> DataStoreDatabricks:
        """Databricks."""
        return self._attributes["databricks"]


    @databricks.setter
    def databricks(self, value: DataStoreDatabricks) -> None:
        _set_attribute(self._attributes, "DataStore", "databricks", value, DataStoreDatabricks, "config")


    @property
    def is_demo_data_store(self) -> bool:
        """Is demo data store."""
        return self._attributes["is_demo_data_store"]


    @is_demo_data_store.setter
    def is_demo_data_store(self, value: bool) -> None:
        _set_attribute(self._attributes, "DataStore", "is_demo_data_store", value, bool, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.DataStore, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.DataStore:
        """Convert object to proto representation."""
        return management_types_pb2.DataStore(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<DataStore object " + repr(self.to_dict()) + ">"


class DataStoreBigQuery:
    """Data store big query."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , auth_file: str = ""
        , auth_file_name: str = ""
        , dataset: str = ""
    , **kwargs) -> DataStoreBigQuery:
        self._attributes = dict()
        self.auth_file = auth_file
        self.auth_file_name = auth_file_name
        self.dataset = dataset

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def auth_file(self) -> str:
        """Auth file."""
        return self._attributes["auth_file"]


    @auth_file.setter
    def auth_file(self, value: str) -> None:
        _set_attribute(self._attributes, "DataStoreBigQuery", "auth_file", value, str, "")


    @property
    def auth_file_name(self) -> str:
        """Auth file name."""
        return self._attributes["auth_file_name"]


    @auth_file_name.setter
    def auth_file_name(self, value: str) -> None:
        _set_attribute(self._attributes, "DataStoreBigQuery", "auth_file_name", value, str, "")


    @property
    def dataset(self) -> str:
        """Dataset."""
        return self._attributes["dataset"]


    @dataset.setter
    def dataset(self, value: str) -> None:
        _set_attribute(self._attributes, "DataStoreBigQuery", "dataset", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.DataStore.BigQuery, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.DataStore.BigQuery:
        """Convert object to proto representation."""
        return management_types_pb2.DataStore.BigQuery(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<DataStoreBigQuery object " + repr(self.to_dict()) + ">"


class DataStoreSnowflake:
    """Data store snowflake."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , host: str = ""
        , port: int = 0
        , username: str = ""
        , password: str = ""
        , database: str = ""
        , warehouse: str = ""
        , role: str = ""
        , params: Dict[str, str] = None
        , db_schema: str = ""
    , **kwargs) -> DataStoreSnowflake:
        self._attributes = dict()
        self.host = host
        self.port = port
        self.username = username
        self.password = password
        self.database = database
        self.warehouse = warehouse
        self.role = role
        self.params = params
        self.db_schema = db_schema

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def host(self) -> str:
        """Host."""
        return self._attributes["host"]


    @host.setter
    def host(self, value: str) -> None:
        _set_attribute(self._attributes, "DataStoreSnowflake", "host", value, str, "")


    @property
    def port(self) -> int:
        """Port."""
        return self._attributes["port"]


    @port.setter
    def port(self, value: int) -> None:
        _set_attribute(self._attributes, "DataStoreSnowflake", "port", value, int, "")


    @property
    def username(self) -> str:
        """Username."""
        return self._attributes["username"]


    @username.setter
    def username(self, value: str) -> None:
        _set_attribute(self._attributes, "DataStoreSnowflake", "username", value, str, "")


    @property
    def password(self) -> str:
        """Password."""
        return self._attributes["password"]


    @password.setter
    def password(self, value: str) -> None:
        _set_attribute(self._attributes, "DataStoreSnowflake", "password", value, str, "")


    @property
    def database(self) -> str:
        """Database."""
        return self._attributes["database"]


    @database.setter
    def database(self, value: str) -> None:
        _set_attribute(self._attributes, "DataStoreSnowflake", "database", value, str, "")


    @property
    def warehouse(self) -> str:
        """Warehouse."""
        return self._attributes["warehouse"]


    @warehouse.setter
    def warehouse(self, value: str) -> None:
        _set_attribute(self._attributes, "DataStoreSnowflake", "warehouse", value, str, "")


    @property
    def role(self) -> str:
        """Role."""
        return self._attributes["role"]


    @role.setter
    def role(self, value: str) -> None:
        _set_attribute(self._attributes, "DataStoreSnowflake", "role", value, str, "")


    @property
    def params(self) -> Dict[str, str]:
        """Params."""
        return self._attributes["params"]


    @params.setter
    def params(self, value: Dict[str, str]) -> None:
        _set_attribute(self._attributes, "DataStoreSnowflake", "params", value, Dict[str, str], "")


    @property
    def db_schema(self) -> str:
        """Db schema."""
        return self._attributes["db_schema"]


    @db_schema.setter
    def db_schema(self, value: str) -> None:
        _set_attribute(self._attributes, "DataStoreSnowflake", "db_schema", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.DataStore.Snowflake, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.DataStore.Snowflake:
        """Convert object to proto representation."""
        return management_types_pb2.DataStore.Snowflake(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<DataStoreSnowflake object " + repr(self.to_dict()) + ">"


class DataStorePostgres:
    """Data store postgres."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , host: str = ""
        , port: int = 0
        , username: str = ""
        , password: str = ""
        , database: str = ""
        , params: Dict[str, str] = None
        , db_schema: str = ""
    , **kwargs) -> DataStorePostgres:
        self._attributes = dict()
        self.host = host
        self.port = port
        self.username = username
        self.password = password
        self.database = database
        self.params = params
        self.db_schema = db_schema

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def host(self) -> str:
        """Host."""
        return self._attributes["host"]


    @host.setter
    def host(self, value: str) -> None:
        _set_attribute(self._attributes, "DataStorePostgres", "host", value, str, "")


    @property
    def port(self) -> int:
        """Port."""
        return self._attributes["port"]


    @port.setter
    def port(self, value: int) -> None:
        _set_attribute(self._attributes, "DataStorePostgres", "port", value, int, "")


    @property
    def username(self) -> str:
        """Username."""
        return self._attributes["username"]


    @username.setter
    def username(self, value: str) -> None:
        _set_attribute(self._attributes, "DataStorePostgres", "username", value, str, "")


    @property
    def password(self) -> str:
        """Password."""
        return self._attributes["password"]


    @password.setter
    def password(self, value: str) -> None:
        _set_attribute(self._attributes, "DataStorePostgres", "password", value, str, "")


    @property
    def database(self) -> str:
        """Database."""
        return self._attributes["database"]


    @database.setter
    def database(self, value: str) -> None:
        _set_attribute(self._attributes, "DataStorePostgres", "database", value, str, "")


    @property
    def params(self) -> Dict[str, str]:
        """Params."""
        return self._attributes["params"]


    @params.setter
    def params(self, value: Dict[str, str]) -> None:
        _set_attribute(self._attributes, "DataStorePostgres", "params", value, Dict[str, str], "")


    @property
    def db_schema(self) -> str:
        """Db schema."""
        return self._attributes["db_schema"]


    @db_schema.setter
    def db_schema(self, value: str) -> None:
        _set_attribute(self._attributes, "DataStorePostgres", "db_schema", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.DataStore.Postgres, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.DataStore.Postgres:
        """Convert object to proto representation."""
        return management_types_pb2.DataStore.Postgres(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<DataStorePostgres object " + repr(self.to_dict()) + ">"


class DataStoreRedshift:
    """Data store redshift."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , host: str = ""
        , port: int = 0
        , username: str = ""
        , password: str = ""
        , database: str = ""
        , params: Dict[str, str] = None
        , db_schema: str = ""
    , **kwargs) -> DataStoreRedshift:
        self._attributes = dict()
        self.host = host
        self.port = port
        self.username = username
        self.password = password
        self.database = database
        self.params = params
        self.db_schema = db_schema

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def host(self) -> str:
        """Host."""
        return self._attributes["host"]


    @host.setter
    def host(self, value: str) -> None:
        _set_attribute(self._attributes, "DataStoreRedshift", "host", value, str, "")


    @property
    def port(self) -> int:
        """Port."""
        return self._attributes["port"]


    @port.setter
    def port(self, value: int) -> None:
        _set_attribute(self._attributes, "DataStoreRedshift", "port", value, int, "")


    @property
    def username(self) -> str:
        """Username."""
        return self._attributes["username"]


    @username.setter
    def username(self, value: str) -> None:
        _set_attribute(self._attributes, "DataStoreRedshift", "username", value, str, "")


    @property
    def password(self) -> str:
        """Password."""
        return self._attributes["password"]


    @password.setter
    def password(self, value: str) -> None:
        _set_attribute(self._attributes, "DataStoreRedshift", "password", value, str, "")


    @property
    def database(self) -> str:
        """Database."""
        return self._attributes["database"]


    @database.setter
    def database(self, value: str) -> None:
        _set_attribute(self._attributes, "DataStoreRedshift", "database", value, str, "")


    @property
    def params(self) -> Dict[str, str]:
        """Params."""
        return self._attributes["params"]


    @params.setter
    def params(self, value: Dict[str, str]) -> None:
        _set_attribute(self._attributes, "DataStoreRedshift", "params", value, Dict[str, str], "")


    @property
    def db_schema(self) -> str:
        """Db schema."""
        return self._attributes["db_schema"]


    @db_schema.setter
    def db_schema(self, value: str) -> None:
        _set_attribute(self._attributes, "DataStoreRedshift", "db_schema", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.DataStore.Redshift, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.DataStore.Redshift:
        """Convert object to proto representation."""
        return management_types_pb2.DataStore.Redshift(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<DataStoreRedshift object " + repr(self.to_dict()) + ">"


class DataStoreDatabricks:
    """Data store databricks."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , host: str = ""
        , port: int = 0
        , token: str = ""
        , http_path: str = ""
        , database: str = ""
        , params: Dict[str, str] = None
        , db_schema: str = ""
    , **kwargs) -> DataStoreDatabricks:
        self._attributes = dict()
        self.host = host
        self.port = port
        self.token = token
        self.http_path = http_path
        self.database = database
        self.params = params
        self.db_schema = db_schema

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def host(self) -> str:
        """Host."""
        return self._attributes["host"]


    @host.setter
    def host(self, value: str) -> None:
        _set_attribute(self._attributes, "DataStoreDatabricks", "host", value, str, "")


    @property
    def port(self) -> int:
        """Port."""
        return self._attributes["port"]


    @port.setter
    def port(self, value: int) -> None:
        _set_attribute(self._attributes, "DataStoreDatabricks", "port", value, int, "")


    @property
    def token(self) -> str:
        """Token."""
        return self._attributes["token"]


    @token.setter
    def token(self, value: str) -> None:
        _set_attribute(self._attributes, "DataStoreDatabricks", "token", value, str, "")


    @property
    def http_path(self) -> str:
        """Http path."""
        return self._attributes["http_path"]


    @http_path.setter
    def http_path(self, value: str) -> None:
        _set_attribute(self._attributes, "DataStoreDatabricks", "http_path", value, str, "")


    @property
    def database(self) -> str:
        """Database."""
        return self._attributes["database"]


    @database.setter
    def database(self, value: str) -> None:
        _set_attribute(self._attributes, "DataStoreDatabricks", "database", value, str, "")


    @property
    def params(self) -> Dict[str, str]:
        """Params."""
        return self._attributes["params"]


    @params.setter
    def params(self, value: Dict[str, str]) -> None:
        _set_attribute(self._attributes, "DataStoreDatabricks", "params", value, Dict[str, str], "")


    @property
    def db_schema(self) -> str:
        """Db schema."""
        return self._attributes["db_schema"]


    @db_schema.setter
    def db_schema(self, value: str) -> None:
        _set_attribute(self._attributes, "DataStoreDatabricks", "db_schema", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.DataStore.Databricks, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.DataStore.Databricks:
        """Convert object to proto representation."""
        return management_types_pb2.DataStore.Databricks(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<DataStoreDatabricks object " + repr(self.to_dict()) + ">"


class HealthCounts:
    """Health counts (healthy, unhealthy, critical)."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , healthy_count: int = 0
        , unhealthy_count: int = 0
        , critical_count: int = 0
    , **kwargs) -> HealthCounts:
        self._attributes = dict()
        self.healthy_count = healthy_count
        self.unhealthy_count = unhealthy_count
        self.critical_count = critical_count

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def healthy_count(self) -> int:
        """Total number in healthy state."""
        return self._attributes["healthy_count"]


    @healthy_count.setter
    def healthy_count(self, value: int) -> None:
        _set_attribute(self._attributes, "HealthCounts", "healthy_count", value, int, "")


    @property
    def unhealthy_count(self) -> int:
        """Total number in unhealthy state."""
        return self._attributes["unhealthy_count"]


    @unhealthy_count.setter
    def unhealthy_count(self, value: int) -> None:
        _set_attribute(self._attributes, "HealthCounts", "unhealthy_count", value, int, "")


    @property
    def critical_count(self) -> int:
        """Total number in critical state."""
        return self._attributes["critical_count"]


    @critical_count.setter
    def critical_count(self, value: int) -> None:
        _set_attribute(self._attributes, "HealthCounts", "critical_count", value, int, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.HealthCounts, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.HealthCounts:
        """Convert object to proto representation."""
        return management_types_pb2.HealthCounts(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<HealthCounts object " + repr(self.to_dict()) + ">"


class Environment:
    """Environment."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , summary: ProjectSummary = None
        , data_store: DataStore = None
        , update_time: datetime = None
        , create_time: datetime = None
        , scheduling_enabled: bool = False
        , source: str = ""
    , **kwargs) -> Environment:
        self._attributes = dict()
        self.name = name
        self.summary = summary
        self.data_store = data_store
        self.update_time = update_time
        self.create_time = create_time
        self.scheduling_enabled = scheduling_enabled
        self.source = source

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """/ Environment resource name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "Environment", "name", value, str, "")


    @property
    def summary(self) -> ProjectSummary:
        """Summary."""
        return self._attributes["summary"]


    @summary.setter
    def summary(self, value: ProjectSummary) -> None:
        _set_attribute(self._attributes, "Environment", "summary", value, ProjectSummary, "")


    @property
    def data_store(self) -> DataStore:
        """Data store."""
        return self._attributes["data_store"]


    @data_store.setter
    def data_store(self, value: DataStore) -> None:
        _set_attribute(self._attributes, "Environment", "data_store", value, DataStore, "")


    @property
    def update_time(self) -> datetime:
        """Update time."""
        return self._attributes["update_time"]


    @update_time.setter
    def update_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Environment", "update_time", value, datetime, "")


    @property
    def create_time(self) -> datetime:
        """Create time."""
        return self._attributes["create_time"]


    @create_time.setter
    def create_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Environment", "create_time", value, datetime, "")


    @property
    def scheduling_enabled(self) -> bool:
        """if scheduled tasts are enabled in this environment."""
        return self._attributes["scheduling_enabled"]


    @scheduling_enabled.setter
    def scheduling_enabled(self, value: bool) -> None:
        _set_attribute(self._attributes, "Environment", "scheduling_enabled", value, bool, "")


    @property
    def source(self) -> str:
        """An environment or project that this environment was created from."""
        return self._attributes["source"]


    @source.setter
    def source(self, value: str) -> None:
        _set_attribute(self._attributes, "Environment", "source", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.Environment, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.Environment:
        """Convert object to proto representation."""
        return management_types_pb2.Environment(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<Environment object " + repr(self.to_dict()) + ">"


class FeatureSetSchema:
    """FeatureSetSchema for feature set."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , type: str = ""
        , name: str = ""
        , entity: str = ""
        , description: str = ""
        , url: str = ""
        , owners: List[str] = []
        , documentation: str = ""
        , profile: ProfileConfig = None
        , columns: List[ColumnConfig] = []
        , exclude_columns: List[str] = []
        , query: str = ""
        , index: str = ""
        , time_index: str = ""
        , split: str = ""
        , table: str = ""
    , **kwargs) -> FeatureSetSchema:
        self._attributes = dict()
        self.type = type
        self.name = name
        self.entity = entity
        self.description = description
        self.url = url
        self.owners = owners
        self.documentation = documentation
        self.profile = profile
        self.columns = columns
        self.exclude_columns = exclude_columns
        self.query = query
        self.index = index
        self.time_index = time_index
        self.split = split
        self.table = table

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def type(self) -> str:
        """FeatureSet."""
        return self._attributes["type"]


    @type.setter
    def type(self, value: str) -> None:
        _set_attribute(self._attributes, "FeatureSetSchema", "type", value, str, "")


    @property
    def name(self) -> str:
        """Unique name for the featureset (e.g. tweets)."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "FeatureSetSchema", "name", value, str, "")


    @property
    def entity(self) -> str:
        """Entity this featureset is part of"""
        return self._attributes["entity"]


    @entity.setter
    def entity(self, value: str) -> None:
        _set_attribute(self._attributes, "FeatureSetSchema", "entity", value, str, "")


    @property
    def description(self) -> str:
        """User provided textual description for the entity."""
        return self._attributes["description"]


    @description.setter
    def description(self, value: str) -> None:
        _set_attribute(self._attributes, "FeatureSetSchema", "description", value, str, "")


    @property
    def url(self) -> str:
        """Documentation URL set by user."""
        return self._attributes["url"]


    @url.setter
    def url(self, value: str) -> None:
        _set_attribute(self._attributes, "FeatureSetSchema", "url", value, str, "")


    @property
    def owners(self) -> List[str]:
        """Set of users emails that own this entity."""
        return self._attributes["owners"]


    @owners.setter
    def owners(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "FeatureSetSchema", "owners", value, List[str], "")


    @property
    def documentation(self) -> str:
        """User documentation of the entity."""
        return self._attributes["documentation"]


    @documentation.setter
    def documentation(self, value: str) -> None:
        _set_attribute(self._attributes, "FeatureSetSchema", "documentation", value, str, "")


    @property
    def profile(self) -> ProfileConfig:
        """Profile."""
        return self._attributes["profile"]


    @profile.setter
    def profile(self, value: ProfileConfig) -> None:
        _set_attribute(self._attributes, "FeatureSetSchema", "profile", value, ProfileConfig, "")


    @property
    def columns(self) -> List[ColumnConfig]:
        """Column Configurations configurations"""
        return self._attributes["columns"]


    @columns.setter
    def columns(self, value: List[ColumnConfig]) -> None:
        _set_attribute(self._attributes, "FeatureSetSchema", "columns", value, List[ColumnConfig], "")


    @property
    def exclude_columns(self) -> List[str]:
        """List of columns to exclude"""
        return self._attributes["exclude_columns"]


    @exclude_columns.setter
    def exclude_columns(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "FeatureSetSchema", "exclude_columns", value, List[str], "")


    @property
    def query(self) -> str:
        """Source configuration"""
        return self._attributes["query"]


    @query.setter
    def query(self, value: str) -> None:
        _set_attribute(self._attributes, "FeatureSetSchema", "query", value, str, "")


    @property
    def index(self) -> str:
        """Index."""
        return self._attributes["index"]


    @index.setter
    def index(self, value: str) -> None:
        _set_attribute(self._attributes, "FeatureSetSchema", "index", value, str, "")


    @property
    def time_index(self) -> str:
        """Time index."""
        return self._attributes["time_index"]


    @time_index.setter
    def time_index(self, value: str) -> None:
        _set_attribute(self._attributes, "FeatureSetSchema", "time_index", value, str, "")


    @property
    def split(self) -> str:
        """Split."""
        return self._attributes["split"]


    @split.setter
    def split(self, value: str) -> None:
        _set_attribute(self._attributes, "FeatureSetSchema", "split", value, str, "")


    @property
    def table(self) -> str:
        """Table."""
        return self._attributes["table"]


    @table.setter
    def table(self, value: str) -> None:
        _set_attribute(self._attributes, "FeatureSetSchema", "table", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.FeatureSetSchema, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.FeatureSetSchema:
        """Convert object to proto representation."""
        return management_types_pb2.FeatureSetSchema(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<FeatureSetSchema object " + repr(self.to_dict()) + ">"


class ModelSchema:
    """Schema for models"""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , type: str = ""
        , name: str = ""
        , description: str = ""
        , url: str = ""
        , owners: List[str] = []
        , documentation: str = ""
        , target: str = ""
        , train: TrainConfig = None
        , predict: PredictConfig = None
        , promote: PromoteConfig = None
        , profile: ProfileConfig = None
        , columns: List[ColumnConfig] = []
        , exclude_columns: List[str] = []
        , include_feature_sets: List[str] = []
        , query: str = ""
        , index: str = ""
        , time_index: str = ""
        , split: str = ""
        , table: str = ""
    , **kwargs) -> ModelSchema:
        self._attributes = dict()
        self.type = type
        self.name = name
        self.description = description
        self.url = url
        self.owners = owners
        self.documentation = documentation
        self.target = target
        self.train = train
        self.predict = predict
        self.promote = promote
        self.profile = profile
        self.columns = columns
        self.exclude_columns = exclude_columns
        self.include_feature_sets = include_feature_sets
        self.query = query
        self.index = index
        self.time_index = time_index
        self.split = split
        self.table = table

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def type(self) -> str:
        """FeatureSet."""
        return self._attributes["type"]


    @type.setter
    def type(self, value: str) -> None:
        _set_attribute(self._attributes, "ModelSchema", "type", value, str, "")


    @property
    def name(self) -> str:
        """Unique name for the featureset (e.g. customer_churn)."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "ModelSchema", "name", value, str, "")


    @property
    def description(self) -> str:
        """User provided textual description for the entity."""
        return self._attributes["description"]


    @description.setter
    def description(self, value: str) -> None:
        _set_attribute(self._attributes, "ModelSchema", "description", value, str, "")


    @property
    def url(self) -> str:
        """Documentation URL set by user."""
        return self._attributes["url"]


    @url.setter
    def url(self, value: str) -> None:
        _set_attribute(self._attributes, "ModelSchema", "url", value, str, "")


    @property
    def owners(self) -> List[str]:
        """Set of users emails that own this entity."""
        return self._attributes["owners"]


    @owners.setter
    def owners(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ModelSchema", "owners", value, List[str], "")


    @property
    def documentation(self) -> str:
        """User documentation of the entity."""
        return self._attributes["documentation"]


    @documentation.setter
    def documentation(self, value: str) -> None:
        _set_attribute(self._attributes, "ModelSchema", "documentation", value, str, "")


    @property
    def target(self) -> str:
        """target column to be predicted"""
        return self._attributes["target"]


    @target.setter
    def target(self, value: str) -> None:
        _set_attribute(self._attributes, "ModelSchema", "target", value, str, "")


    @property
    def train(self) -> TrainConfig:
        """Training config"""
        return self._attributes["train"]


    @train.setter
    def train(self, value: TrainConfig) -> None:
        _set_attribute(self._attributes, "ModelSchema", "train", value, TrainConfig, "")


    @property
    def predict(self) -> PredictConfig:
        """Predict."""
        return self._attributes["predict"]


    @predict.setter
    def predict(self, value: PredictConfig) -> None:
        _set_attribute(self._attributes, "ModelSchema", "predict", value, PredictConfig, "")


    @property
    def promote(self) -> PromoteConfig:
        """Promote."""
        return self._attributes["promote"]


    @promote.setter
    def promote(self, value: PromoteConfig) -> None:
        _set_attribute(self._attributes, "ModelSchema", "promote", value, PromoteConfig, "")


    @property
    def profile(self) -> ProfileConfig:
        """Profile."""
        return self._attributes["profile"]


    @profile.setter
    def profile(self, value: ProfileConfig) -> None:
        _set_attribute(self._attributes, "ModelSchema", "profile", value, ProfileConfig, "")


    @property
    def columns(self) -> List[ColumnConfig]:
        """Column Configurations configurations"""
        return self._attributes["columns"]


    @columns.setter
    def columns(self, value: List[ColumnConfig]) -> None:
        _set_attribute(self._attributes, "ModelSchema", "columns", value, List[ColumnConfig], "")


    @property
    def exclude_columns(self) -> List[str]:
        """List of columns to exclude"""
        return self._attributes["exclude_columns"]


    @exclude_columns.setter
    def exclude_columns(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ModelSchema", "exclude_columns", value, List[str], "")


    @property
    def include_feature_sets(self) -> List[str]:
        """List of featuresets to include in joins"""
        return self._attributes["include_feature_sets"]


    @include_feature_sets.setter
    def include_feature_sets(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ModelSchema", "include_feature_sets", value, List[str], "")


    @property
    def query(self) -> str:
        """Source configuration"""
        return self._attributes["query"]


    @query.setter
    def query(self, value: str) -> None:
        _set_attribute(self._attributes, "ModelSchema", "query", value, str, "")


    @property
    def index(self) -> str:
        """Index."""
        return self._attributes["index"]


    @index.setter
    def index(self, value: str) -> None:
        _set_attribute(self._attributes, "ModelSchema", "index", value, str, "")


    @property
    def time_index(self) -> str:
        """Time index."""
        return self._attributes["time_index"]


    @time_index.setter
    def time_index(self, value: str) -> None:
        _set_attribute(self._attributes, "ModelSchema", "time_index", value, str, "")


    @property
    def split(self) -> str:
        """Split."""
        return self._attributes["split"]


    @split.setter
    def split(self, value: str) -> None:
        _set_attribute(self._attributes, "ModelSchema", "split", value, str, "")


    @property
    def table(self) -> str:
        """Table."""
        return self._attributes["table"]


    @table.setter
    def table(self, value: str) -> None:
        _set_attribute(self._attributes, "ModelSchema", "table", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.ModelSchema, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.ModelSchema:
        """Convert object to proto representation."""
        return management_types_pb2.ModelSchema(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ModelSchema object " + repr(self.to_dict()) + ">"


class ColumnConfig:
    """Field Config."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , description: str = ""
        , entity: str = ""
        , type: FieldType = 0
        , dtype: str = ""
    , **kwargs) -> ColumnConfig:
        self._attributes = dict()
        self.name = name
        self.description = description
        self.entity = entity
        self.type = type
        self.dtype = dtype

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "ColumnConfig", "name", value, str, "")


    @property
    def description(self) -> str:
        """Description."""
        return self._attributes["description"]


    @description.setter
    def description(self, value: str) -> None:
        _set_attribute(self._attributes, "ColumnConfig", "description", value, str, "")


    @property
    def entity(self) -> str:
        """Entity."""
        return self._attributes["entity"]


    @entity.setter
    def entity(self, value: str) -> None:
        _set_attribute(self._attributes, "ColumnConfig", "entity", value, str, "")


    @property
    def type(self) -> FieldType:
        """Type."""
        return self._attributes["type"]


    @type.setter
    def type(self, value: FieldType) -> None:
        _set_attribute(self._attributes, "ColumnConfig", "type", value, FieldType, "")


    @property
    def dtype(self) -> str:
        """Dtype."""
        return self._attributes["dtype"]


    @dtype.setter
    def dtype(self, value: str) -> None:
        _set_attribute(self._attributes, "ColumnConfig", "dtype", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.ColumnConfig, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.ColumnConfig:
        """Convert object to proto representation."""
        return management_types_pb2.ColumnConfig(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ColumnConfig object " + repr(self.to_dict()) + ">"


class TrainConfig:
    """Config for model training."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , schedule: str = ""
        , metric: str = ""
        , optimization: str = ""
        , advanced: str = ""
        , included_model_types: List[str] = []
        , excluded_model_types: List[str] = []
        , size: str = ""
        , plots: List[str] = []
        , exclude_ensemble: bool = False
        , disable_data_checks: bool = False
        , time_limit: int = 0
        , size_limit: int = 0
    , **kwargs) -> TrainConfig:
        self._attributes = dict()
        self.schedule = schedule
        self.metric = metric
        self.optimization = optimization
        self.advanced = advanced
        self.included_model_types = included_model_types
        self.excluded_model_types = excluded_model_types
        self.size = size
        self.plots = plots
        self.exclude_ensemble = exclude_ensemble
        self.disable_data_checks = disable_data_checks
        self.time_limit = time_limit
        self.size_limit = size_limit

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def schedule(self) -> str:
        """Schedule."""
        return self._attributes["schedule"]


    @schedule.setter
    def schedule(self, value: str) -> None:
        _set_attribute(self._attributes, "TrainConfig", "schedule", value, str, "")


    @property
    def metric(self) -> str:
        """Metric."""
        return self._attributes["metric"]


    @metric.setter
    def metric(self, value: str) -> None:
        _set_attribute(self._attributes, "TrainConfig", "metric", value, str, "")


    @property
    def optimization(self) -> str:
        """Optimization."""
        return self._attributes["optimization"]


    @optimization.setter
    def optimization(self, value: str) -> None:
        _set_attribute(self._attributes, "TrainConfig", "optimization", value, str, "")


    @property
    def advanced(self) -> str:
        """Advanced."""
        return self._attributes["advanced"]


    @advanced.setter
    def advanced(self, value: str) -> None:
        _set_attribute(self._attributes, "TrainConfig", "advanced", value, str, "")


    @property
    def included_model_types(self) -> List[str]:
        """Included model types."""
        return self._attributes["included_model_types"]


    @included_model_types.setter
    def included_model_types(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "TrainConfig", "included_model_types", value, List[str], "")


    @property
    def excluded_model_types(self) -> List[str]:
        """Excluded model types."""
        return self._attributes["excluded_model_types"]


    @excluded_model_types.setter
    def excluded_model_types(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "TrainConfig", "excluded_model_types", value, List[str], "")


    @property
    def size(self) -> str:
        """Size."""
        return self._attributes["size"]


    @size.setter
    def size(self, value: str) -> None:
        _set_attribute(self._attributes, "TrainConfig", "size", value, str, "")


    @property
    def plots(self) -> List[str]:
        """Plots."""
        return self._attributes["plots"]


    @plots.setter
    def plots(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "TrainConfig", "plots", value, List[str], "")


    @property
    def exclude_ensemble(self) -> bool:
        """Exclude ensemble."""
        return self._attributes["exclude_ensemble"]


    @exclude_ensemble.setter
    def exclude_ensemble(self, value: bool) -> None:
        _set_attribute(self._attributes, "TrainConfig", "exclude_ensemble", value, bool, "")


    @property
    def disable_data_checks(self) -> bool:
        """Disable data checks."""
        return self._attributes["disable_data_checks"]


    @disable_data_checks.setter
    def disable_data_checks(self, value: bool) -> None:
        _set_attribute(self._attributes, "TrainConfig", "disable_data_checks", value, bool, "")


    @property
    def time_limit(self) -> int:
        """Time limit."""
        return self._attributes["time_limit"]


    @time_limit.setter
    def time_limit(self, value: int) -> None:
        _set_attribute(self._attributes, "TrainConfig", "time_limit", value, int, "")


    @property
    def size_limit(self) -> int:
        """Size limit."""
        return self._attributes["size_limit"]


    @size_limit.setter
    def size_limit(self, value: int) -> None:
        _set_attribute(self._attributes, "TrainConfig", "size_limit", value, int, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.TrainConfig, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.TrainConfig:
        """Convert object to proto representation."""
        return management_types_pb2.TrainConfig(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<TrainConfig object " + repr(self.to_dict()) + ">"


class PredictConfig:
    """Config for batch prediction schedule."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , schedule: str = ""
        , incremental: bool = False
    , **kwargs) -> PredictConfig:
        self._attributes = dict()
        self.schedule = schedule
        self.incremental = incremental

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def schedule(self) -> str:
        """Schedule."""
        return self._attributes["schedule"]


    @schedule.setter
    def schedule(self, value: str) -> None:
        _set_attribute(self._attributes, "PredictConfig", "schedule", value, str, "")


    @property
    def incremental(self) -> bool:
        """Incremental."""
        return self._attributes["incremental"]


    @incremental.setter
    def incremental(self, value: bool) -> None:
        _set_attribute(self._attributes, "PredictConfig", "incremental", value, bool, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.PredictConfig, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.PredictConfig:
        """Convert object to proto representation."""
        return management_types_pb2.PredictConfig(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<PredictConfig object " + repr(self.to_dict()) + ">"


class PromoteConfig:
    """Config for promotion"""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , policy: str = ""
    , **kwargs) -> PromoteConfig:
        self._attributes = dict()
        self.policy = policy

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def policy(self) -> str:
        """Policy."""
        return self._attributes["policy"]


    @policy.setter
    def policy(self, value: str) -> None:
        _set_attribute(self._attributes, "PromoteConfig", "policy", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.PromoteConfig, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.PromoteConfig:
        """Convert object to proto representation."""
        return management_types_pb2.PromoteConfig(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<PromoteConfig object " + repr(self.to_dict()) + ">"


class ProfileConfig:
    """Config for profile schedule."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , schedule: str = ""
    , **kwargs) -> ProfileConfig:
        self._attributes = dict()
        self.schedule = schedule

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def schedule(self) -> str:
        """Schedule."""
        return self._attributes["schedule"]


    @schedule.setter
    def schedule(self, value: str) -> None:
        _set_attribute(self._attributes, "ProfileConfig", "schedule", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.ProfileConfig, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.ProfileConfig:
        """Convert object to proto representation."""
        return management_types_pb2.ProfileConfig(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ProfileConfig object " + repr(self.to_dict()) + ">"


class SourceConfig:
    """Defines an entity's data source."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , connection: str = ""
        , query: str = ""
        , schedule: str = ""
        , file: str = ""
        , incremental_column: str = ""
    , **kwargs) -> SourceConfig:
        self._attributes = dict()
        self.connection = connection
        self.query = query
        self.schedule = schedule
        self.file = file
        self.incremental_column = incremental_column

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def connection(self) -> str:
        """Name of the connection object."""
        return self._attributes["connection"]


    @connection.setter
    def connection(self, value: str) -> None:
        _set_attribute(self._attributes, "SourceConfig", "connection", value, str, "")


    @property
    def query(self) -> str:
        """For database connections, query to use for fetching data."""
        return self._attributes["query"]


    @query.setter
    def query(self, value: str) -> None:
        _set_attribute(self._attributes, "SourceConfig", "query", value, str, "")


    @property
    def schedule(self) -> str:
        """Schedule at which data is to be fetched. Hourly, Daily, weekly, Monthly."""
        return self._attributes["schedule"]


    @schedule.setter
    def schedule(self, value: str) -> None:
        _set_attribute(self._attributes, "SourceConfig", "schedule", value, str, "")


    @property
    def file(self) -> str:
        """Cloud filename path for file based ingest."""
        return self._attributes["file"]


    @file.setter
    def file(self, value: str) -> None:
        _set_attribute(self._attributes, "SourceConfig", "file", value, str, "")


    @property
    def incremental_column(self) -> str:
        """Column to be used for incremental data fetch"""
        return self._attributes["incremental_column"]


    @incremental_column.setter
    def incremental_column(self, value: str) -> None:
        _set_attribute(self._attributes, "SourceConfig", "incremental_column", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.SourceConfig, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.SourceConfig:
        """Convert object to proto representation."""
        return management_types_pb2.SourceConfig(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<SourceConfig object " + repr(self.to_dict()) + ">"


class FeatureSet:
    """FeatureSet object."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , schema: FeatureSetSchema = None
        , schema_text: str = ""
        , create_time: datetime = None
        , update_time: datetime = None
        , table: str = ""
    , **kwargs) -> FeatureSet:
        self._attributes = dict()
        self.name = name
        self.schema = schema
        self.schema_text = schema_text
        self.create_time = create_time
        self.update_time = update_time
        self.table = table

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Fully qualified and versioned FeatureSet name including version.
 Example: projects/:project/featureset/:featureset@:version"""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "FeatureSet", "name", value, str, "")


    @property
    def schema(self) -> FeatureSetSchema:
        """Feature set schema definition."""
        return self._attributes["schema"]


    @schema.setter
    def schema(self, value: FeatureSetSchema) -> None:
        _set_attribute(self._attributes, "FeatureSet", "schema", value, FeatureSetSchema, "")


    @property
    def schema_text(self) -> str:
        """Feature set schema YAML representation."""
        return self._attributes["schema_text"]


    @schema_text.setter
    def schema_text(self, value: str) -> None:
        _set_attribute(self._attributes, "FeatureSet", "schema_text", value, str, "")


    @property
    def create_time(self) -> datetime:
        """Time feature set version created."""
        return self._attributes["create_time"]


    @create_time.setter
    def create_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "FeatureSet", "create_time", value, datetime, "")


    @property
    def update_time(self) -> datetime:
        """Time feature set was updated."""
        return self._attributes["update_time"]


    @update_time.setter
    def update_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "FeatureSet", "update_time", value, datetime, "")


    @property
    def table(self) -> str:
        """Table."""
        return self._attributes["table"]


    @table.setter
    def table(self, value: str) -> None:
        _set_attribute(self._attributes, "FeatureSet", "table", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.FeatureSet, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.FeatureSet:
        """Convert object to proto representation."""
        return management_types_pb2.FeatureSet(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<FeatureSet object " + repr(self.to_dict()) + ">"


class ColumnStats:
    """Column stats."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , column_name: str = ""
        , distinct_values: float = 0.0
        , min: float = 0.0
        , max: float = 0.0
        , sd: float = 0.0
        , mean: float = 0.0
        , count: int = 0
        , null_count: int = 0
        , min_length: int = 0
        , max_length: int = 0
        , earliest: datetime = None
        , latest: datetime = None
        , type: FieldType = 0
    , **kwargs) -> ColumnStats:
        self._attributes = dict()
        self.column_name = column_name
        self.distinct_values = distinct_values
        self.min = min
        self.max = max
        self.sd = sd
        self.mean = mean
        self.count = count
        self.null_count = null_count
        self.min_length = min_length
        self.max_length = max_length
        self.earliest = earliest
        self.latest = latest
        self.type = type

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def column_name(self) -> str:
        """Column name."""
        return self._attributes["column_name"]


    @column_name.setter
    def column_name(self, value: str) -> None:
        _set_attribute(self._attributes, "ColumnStats", "column_name", value, str, "")


    @property
    def distinct_values(self) -> float:
        """Distinct values."""
        return self._attributes["distinct_values"]


    @distinct_values.setter
    def distinct_values(self, value: float) -> None:
        _set_attribute(self._attributes, "ColumnStats", "distinct_values", value, float, "")


    @property
    def min(self) -> float:
        """Min."""
        return self._attributes["min"]


    @min.setter
    def min(self, value: float) -> None:
        _set_attribute(self._attributes, "ColumnStats", "min", value, float, "")


    @property
    def max(self) -> float:
        """Max."""
        return self._attributes["max"]


    @max.setter
    def max(self, value: float) -> None:
        _set_attribute(self._attributes, "ColumnStats", "max", value, float, "")


    @property
    def sd(self) -> float:
        """Sd."""
        return self._attributes["sd"]


    @sd.setter
    def sd(self, value: float) -> None:
        _set_attribute(self._attributes, "ColumnStats", "sd", value, float, "")


    @property
    def mean(self) -> float:
        """Mean."""
        return self._attributes["mean"]


    @mean.setter
    def mean(self, value: float) -> None:
        _set_attribute(self._attributes, "ColumnStats", "mean", value, float, "")


    @property
    def count(self) -> int:
        """Count."""
        return self._attributes["count"]


    @count.setter
    def count(self, value: int) -> None:
        _set_attribute(self._attributes, "ColumnStats", "count", value, int, "")


    @property
    def null_count(self) -> int:
        """Null count."""
        return self._attributes["null_count"]


    @null_count.setter
    def null_count(self, value: int) -> None:
        _set_attribute(self._attributes, "ColumnStats", "null_count", value, int, "")


    @property
    def min_length(self) -> int:
        """Min length."""
        return self._attributes["min_length"]


    @min_length.setter
    def min_length(self, value: int) -> None:
        _set_attribute(self._attributes, "ColumnStats", "min_length", value, int, "")


    @property
    def max_length(self) -> int:
        """Max length."""
        return self._attributes["max_length"]


    @max_length.setter
    def max_length(self, value: int) -> None:
        _set_attribute(self._attributes, "ColumnStats", "max_length", value, int, "")


    @property
    def earliest(self) -> datetime:
        """Earliest."""
        return self._attributes["earliest"]


    @earliest.setter
    def earliest(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ColumnStats", "earliest", value, datetime, "")


    @property
    def latest(self) -> datetime:
        """Latest."""
        return self._attributes["latest"]


    @latest.setter
    def latest(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ColumnStats", "latest", value, datetime, "")


    @property
    def type(self) -> FieldType:
        """Type."""
        return self._attributes["type"]


    @type.setter
    def type(self, value: FieldType) -> None:
        _set_attribute(self._attributes, "ColumnStats", "type", value, FieldType, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.ColumnStats, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.ColumnStats:
        """Convert object to proto representation."""
        return management_types_pb2.ColumnStats(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ColumnStats object " + repr(self.to_dict()) + ">"


class ColumnSetStats:
    """Column set stats."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , computed_at: datetime = None
        , row_count: int = 0
        , total_bytes: int = 0
        , columns: List[ColumnStats] = []
        , has_time_index: bool = False
        , start_time: datetime = None
        , end_time: datetime = None
    , **kwargs) -> ColumnSetStats:
        self._attributes = dict()
        self.name = name
        self.computed_at = computed_at
        self.row_count = row_count
        self.total_bytes = total_bytes
        self.columns = columns
        self.has_time_index = has_time_index
        self.start_time = start_time
        self.end_time = end_time

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Featureset name"""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "ColumnSetStats", "name", value, str, "")


    @property
    def computed_at(self) -> datetime:
        """Featureset name"""
        return self._attributes["computed_at"]


    @computed_at.setter
    def computed_at(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ColumnSetStats", "computed_at", value, datetime, "")


    @property
    def row_count(self) -> int:
        """Rows in the featureset."""
        return self._attributes["row_count"]


    @row_count.setter
    def row_count(self, value: int) -> None:
        _set_attribute(self._attributes, "ColumnSetStats", "row_count", value, int, "")


    @property
    def total_bytes(self) -> int:
        """Size of the data corpus in number of bytes."""
        return self._attributes["total_bytes"]


    @total_bytes.setter
    def total_bytes(self, value: int) -> None:
        _set_attribute(self._attributes, "ColumnSetStats", "total_bytes", value, int, "")


    @property
    def columns(self) -> List[ColumnStats]:
        """Statistics for each of the feature in the featureset"""
        return self._attributes["columns"]


    @columns.setter
    def columns(self, value: List[ColumnStats]) -> None:
        _set_attribute(self._attributes, "ColumnSetStats", "columns", value, List[ColumnStats], "")


    @property
    def has_time_index(self) -> bool:
        """if the feature set or model has a time index"""
        return self._attributes["has_time_index"]


    @has_time_index.setter
    def has_time_index(self, value: bool) -> None:
        _set_attribute(self._attributes, "ColumnSetStats", "has_time_index", value, bool, "")


    @property
    def start_time(self) -> datetime:
        """Start time."""
        return self._attributes["start_time"]


    @start_time.setter
    def start_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ColumnSetStats", "start_time", value, datetime, "")


    @property
    def end_time(self) -> datetime:
        """End time."""
        return self._attributes["end_time"]


    @end_time.setter
    def end_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ColumnSetStats", "end_time", value, datetime, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.ColumnSetStats, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.ColumnSetStats:
        """Convert object to proto representation."""
        return management_types_pb2.ColumnSetStats(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ColumnSetStats object " + repr(self.to_dict()) + ">"


class Event:
    """Event captures and activity event."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , subject: str = ""
        , event: str = ""
        , resource: str = ""
        , severity: str = ""
        , message: str = ""
        , data: Dict[str, str] = None
        , create_time: datetime = None
    , **kwargs) -> Event:
        self._attributes = dict()
        self.name = name
        self.subject = subject
        self.event = event
        self.resource = resource
        self.severity = severity
        self.message = message
        self.data = data
        self.create_time = create_time

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Unique name for event."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "Event", "name", value, str, "")


    @property
    def subject(self) -> str:
        """User or account that took action."""
        return self._attributes["subject"]


    @subject.setter
    def subject(self, value: str) -> None:
        _set_attribute(self._attributes, "Event", "subject", value, str, "")


    @property
    def event(self) -> str:
        """Event type."""
        return self._attributes["event"]


    @event.setter
    def event(self, value: str) -> None:
        _set_attribute(self._attributes, "Event", "event", value, str, "")


    @property
    def resource(self) -> str:
        """Resource on which the action was taken."""
        return self._attributes["resource"]


    @resource.setter
    def resource(self, value: str) -> None:
        _set_attribute(self._attributes, "Event", "resource", value, str, "")


    @property
    def severity(self) -> str:
        """Severity level."""
        return self._attributes["severity"]


    @severity.setter
    def severity(self, value: str) -> None:
        _set_attribute(self._attributes, "Event", "severity", value, str, "")


    @property
    def message(self) -> str:
        """Human readable message."""
        return self._attributes["message"]


    @message.setter
    def message(self, value: str) -> None:
        _set_attribute(self._attributes, "Event", "message", value, str, "")


    @property
    def data(self) -> Dict[str, str]:
        """Extra data."""
        return self._attributes["data"]


    @data.setter
    def data(self, value: Dict[str, str]) -> None:
        _set_attribute(self._attributes, "Event", "data", value, Dict[str, str], "")


    @property
    def create_time(self) -> datetime:
        """Event time."""
        return self._attributes["create_time"]


    @create_time.setter
    def create_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Event", "create_time", value, datetime, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.Event, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.Event:
        """Convert object to proto representation."""
        return management_types_pb2.Event(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<Event object " + repr(self.to_dict()) + ">"


class ServingMetric:
    """Serving metric."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , model: str = ""
        , parent: str = ""
        , tag: str = ""
        , request_start_time: datetime = None
        , model_start_time: datetime = None
        , request_duration: timedelta = None
        , route_duration: timedelta = None
        , feature_duration: timedelta = None
        , predict_duration: timedelta = None
        , model_duration: timedelta = None
        , model_version: str = ""
        , result_code: str = ""
        , result_data: str = ""
    , **kwargs) -> ServingMetric:
        self._attributes = dict()
        self.model = model
        self.parent = parent
        self.tag = tag
        self.request_start_time = request_start_time
        self.model_start_time = model_start_time
        self.request_duration = request_duration
        self.route_duration = route_duration
        self.feature_duration = feature_duration
        self.predict_duration = predict_duration
        self.model_duration = model_duration
        self.model_version = model_version
        self.result_code = result_code
        self.result_data = result_data

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def model(self) -> str:
        """Model."""
        return self._attributes["model"]


    @model.setter
    def model(self, value: str) -> None:
        _set_attribute(self._attributes, "ServingMetric", "model", value, str, "")


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "ServingMetric", "parent", value, str, "")


    @property
    def tag(self) -> str:
        """Tag."""
        return self._attributes["tag"]


    @tag.setter
    def tag(self, value: str) -> None:
        _set_attribute(self._attributes, "ServingMetric", "tag", value, str, "")


    @property
    def request_start_time(self) -> datetime:
        """Request start time."""
        return self._attributes["request_start_time"]


    @request_start_time.setter
    def request_start_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ServingMetric", "request_start_time", value, datetime, "")


    @property
    def model_start_time(self) -> datetime:
        """Model start time."""
        return self._attributes["model_start_time"]


    @model_start_time.setter
    def model_start_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ServingMetric", "model_start_time", value, datetime, "")


    @property
    def request_duration(self) -> timedelta:
        """Request duration."""
        return self._attributes["request_duration"]


    @request_duration.setter
    def request_duration(self, value: timedelta) -> None:
        _set_attribute(self._attributes, "ServingMetric", "request_duration", value, timedelta, "")


    @property
    def route_duration(self) -> timedelta:
        """Route duration."""
        return self._attributes["route_duration"]


    @route_duration.setter
    def route_duration(self, value: timedelta) -> None:
        _set_attribute(self._attributes, "ServingMetric", "route_duration", value, timedelta, "")


    @property
    def feature_duration(self) -> timedelta:
        """Feature duration."""
        return self._attributes["feature_duration"]


    @feature_duration.setter
    def feature_duration(self, value: timedelta) -> None:
        _set_attribute(self._attributes, "ServingMetric", "feature_duration", value, timedelta, "")


    @property
    def predict_duration(self) -> timedelta:
        """Predict duration."""
        return self._attributes["predict_duration"]


    @predict_duration.setter
    def predict_duration(self, value: timedelta) -> None:
        _set_attribute(self._attributes, "ServingMetric", "predict_duration", value, timedelta, "")


    @property
    def model_duration(self) -> timedelta:
        """Model duration."""
        return self._attributes["model_duration"]


    @model_duration.setter
    def model_duration(self, value: timedelta) -> None:
        _set_attribute(self._attributes, "ServingMetric", "model_duration", value, timedelta, "")


    @property
    def model_version(self) -> str:
        """Model version."""
        return self._attributes["model_version"]


    @model_version.setter
    def model_version(self, value: str) -> None:
        _set_attribute(self._attributes, "ServingMetric", "model_version", value, str, "")


    @property
    def result_code(self) -> str:
        """Result code."""
        return self._attributes["result_code"]


    @result_code.setter
    def result_code(self, value: str) -> None:
        _set_attribute(self._attributes, "ServingMetric", "result_code", value, str, "")


    @property
    def result_data(self) -> str:
        """Result data."""
        return self._attributes["result_data"]


    @result_data.setter
    def result_data(self, value: str) -> None:
        _set_attribute(self._attributes, "ServingMetric", "result_data", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.ServingMetric, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.ServingMetric:
        """Convert object to proto representation."""
        return management_types_pb2.ServingMetric(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ServingMetric object " + repr(self.to_dict()) + ">"


class Model:
    """A model represents a machine learning task."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , state: ModelState = 0
        , schema: ModelSchema = None
        , schema_text: str = ""
        , latest_model_version: str = ""
        , create_time: datetime = None
        , update_time: datetime = None
        , latest_batch_prediction: str = ""
        , current_version: str = ""
        , table: str = ""
    , **kwargs) -> Model:
        self._attributes = dict()
        self.name = name
        self.state = state
        self.schema = schema
        self.schema_text = schema_text
        self.latest_model_version = latest_model_version
        self.create_time = create_time
        self.update_time = update_time
        self.latest_batch_prediction = latest_batch_prediction
        self.current_version = current_version
        self.table = table

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Model resource name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "Model", "name", value, str, "")


    @property
    def state(self) -> ModelState:
        """Model state."""
        return self._attributes["state"]


    @state.setter
    def state(self, value: ModelState) -> None:
        _set_attribute(self._attributes, "Model", "state", value, ModelState, "")


    @property
    def schema(self) -> ModelSchema:
        """Model configuration."""
        return self._attributes["schema"]


    @schema.setter
    def schema(self, value: ModelSchema) -> None:
        _set_attribute(self._attributes, "Model", "schema", value, ModelSchema, "")


    @property
    def schema_text(self) -> str:
        """Schema text."""
        return self._attributes["schema_text"]


    @schema_text.setter
    def schema_text(self, value: str) -> None:
        _set_attribute(self._attributes, "Model", "schema_text", value, str, "")


    @property
    def latest_model_version(self) -> str:
        """Latest model version."""
        return self._attributes["latest_model_version"]


    @latest_model_version.setter
    def latest_model_version(self, value: str) -> None:
        _set_attribute(self._attributes, "Model", "latest_model_version", value, str, "")


    @property
    def create_time(self) -> datetime:
        """First time model was created."""
        return self._attributes["create_time"]


    @create_time.setter
    def create_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Model", "create_time", value, datetime, "")


    @property
    def update_time(self) -> datetime:
        """Last time model feature set was updated."""
        return self._attributes["update_time"]


    @update_time.setter
    def update_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Model", "update_time", value, datetime, "")


    @property
    def latest_batch_prediction(self) -> str:
        """Latest batch prediction."""
        return self._attributes["latest_batch_prediction"]


    @latest_batch_prediction.setter
    def latest_batch_prediction(self, value: str) -> None:
        _set_attribute(self._attributes, "Model", "latest_batch_prediction", value, str, "")


    @property
    def current_version(self) -> str:
        """Current version."""
        return self._attributes["current_version"]


    @current_version.setter
    def current_version(self, value: str) -> None:
        _set_attribute(self._attributes, "Model", "current_version", value, str, "")


    @property
    def table(self) -> str:
        """Table."""
        return self._attributes["table"]


    @table.setter
    def table(self, value: str) -> None:
        _set_attribute(self._attributes, "Model", "table", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.Model, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.Model:
        """Convert object to proto representation."""
        return management_types_pb2.Model(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<Model object " + repr(self.to_dict()) + ">"


class Promotion:
    """Model Promotion of a particular model version."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , create_time: datetime = None
        , promoted_time: datetime = None
        , demoted_time: datetime = None
        , model_version: str = ""
        , base_model_version: str = ""
        , state: PromotionState = 0
        , improvement_metric: str = ""
        , improvement_metric_value: float = 0.0
        , base_improvement_metric_value: float = 0.0
        , improvement_metric_diff: float = 0.0
        , decision: PromotionDecision = 0
        , reason: PromotionReason = 0
        , message: str = ""
        , manual: bool = False
        , account: str = ""
    , **kwargs) -> Promotion:
        self._attributes = dict()
        self.name = name
        self.create_time = create_time
        self.promoted_time = promoted_time
        self.demoted_time = demoted_time
        self.model_version = model_version
        self.base_model_version = base_model_version
        self.state = state
        self.improvement_metric = improvement_metric
        self.improvement_metric_value = improvement_metric_value
        self.base_improvement_metric_value = base_improvement_metric_value
        self.improvement_metric_diff = improvement_metric_diff
        self.decision = decision
        self.reason = reason
        self.message = message
        self.manual = manual
        self.account = account

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Fully qualified name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "Promotion", "name", value, str, "")


    @property
    def create_time(self) -> datetime:
        """Create time."""
        return self._attributes["create_time"]


    @create_time.setter
    def create_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Promotion", "create_time", value, datetime, "")


    @property
    def promoted_time(self) -> datetime:
        """When the model was promoted."""
        return self._attributes["promoted_time"]


    @promoted_time.setter
    def promoted_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Promotion", "promoted_time", value, datetime, "")


    @property
    def demoted_time(self) -> datetime:
        """When the model was demoted."""
        return self._attributes["demoted_time"]


    @demoted_time.setter
    def demoted_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Promotion", "demoted_time", value, datetime, "")


    @property
    def model_version(self) -> str:
        """Fully qualified model version name."""
        return self._attributes["model_version"]


    @model_version.setter
    def model_version(self, value: str) -> None:
        _set_attribute(self._attributes, "Promotion", "model_version", value, str, "")


    @property
    def base_model_version(self) -> str:
        """Base model version."""
        return self._attributes["base_model_version"]


    @base_model_version.setter
    def base_model_version(self, value: str) -> None:
        _set_attribute(self._attributes, "Promotion", "base_model_version", value, str, "")


    @property
    def state(self) -> PromotionState:
        """Current state"""
        return self._attributes["state"]


    @state.setter
    def state(self, value: PromotionState) -> None:
        _set_attribute(self._attributes, "Promotion", "state", value, PromotionState, "")


    @property
    def improvement_metric(self) -> str:
        """Improvement of metric (e.g. RMSE, accuracy, precision)"""
        return self._attributes["improvement_metric"]


    @improvement_metric.setter
    def improvement_metric(self, value: str) -> None:
        _set_attribute(self._attributes, "Promotion", "improvement_metric", value, str, "")


    @property
    def improvement_metric_value(self) -> float:
        """Improvement of metric value (model_version - current promoted model if any, otherwise 0)"""
        return self._attributes["improvement_metric_value"]


    @improvement_metric_value.setter
    def improvement_metric_value(self, value: float) -> None:
        _set_attribute(self._attributes, "Promotion", "improvement_metric_value", value, float, "")


    @property
    def base_improvement_metric_value(self) -> float:
        """Base improvement metric value."""
        return self._attributes["base_improvement_metric_value"]


    @base_improvement_metric_value.setter
    def base_improvement_metric_value(self, value: float) -> None:
        _set_attribute(self._attributes, "Promotion", "base_improvement_metric_value", value, float, "")


    @property
    def improvement_metric_diff(self) -> float:
        """Improvement metric diff."""
        return self._attributes["improvement_metric_diff"]


    @improvement_metric_diff.setter
    def improvement_metric_diff(self, value: float) -> None:
        _set_attribute(self._attributes, "Promotion", "improvement_metric_diff", value, float, "")


    @property
    def decision(self) -> PromotionDecision:
        """Decision."""
        return self._attributes["decision"]


    @decision.setter
    def decision(self, value: PromotionDecision) -> None:
        _set_attribute(self._attributes, "Promotion", "decision", value, PromotionDecision, "")


    @property
    def reason(self) -> PromotionReason:
        """Reason."""
        return self._attributes["reason"]


    @reason.setter
    def reason(self, value: PromotionReason) -> None:
        _set_attribute(self._attributes, "Promotion", "reason", value, PromotionReason, "")


    @property
    def message(self) -> str:
        """Message."""
        return self._attributes["message"]


    @message.setter
    def message(self, value: str) -> None:
        _set_attribute(self._attributes, "Promotion", "message", value, str, "")


    @property
    def manual(self) -> bool:
        """If promotion was manually promoted by user."""
        return self._attributes["manual"]


    @manual.setter
    def manual(self, value: bool) -> None:
        _set_attribute(self._attributes, "Promotion", "manual", value, bool, "")


    @property
    def account(self) -> str:
        """user or system account initiating promotion"""
        return self._attributes["account"]


    @account.setter
    def account(self, value: str) -> None:
        _set_attribute(self._attributes, "Promotion", "account", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.Promotion, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.Promotion:
        """Convert object to proto representation."""
        return management_types_pb2.Promotion(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<Promotion object " + repr(self.to_dict()) + ">"


class ModelVersion:
    """A model version represents a particular trained model version."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , model_version_id: int = 0
        , model_signature: str = ""
        , experiment: str = ""
        , storage_uri: str = ""
        , model_version_format: str = ""
        , state: ModelVersionState = 0
        , error_message: str = ""
        , stack_trace: str = ""
        , system_time: datetime = None
        , visible_start_time: datetime = None
        , visible_stop_time: datetime = None
        , create_time: datetime = None
        , update_time: datetime = None
        , start_time: datetime = None
        , end_time: datetime = None
        , platform_version: str = ""
        , training_row_count: int = 0
        , validation_row_count: int = 0
        , test_row_count: int = 0
        , performance_metric: str = ""
        , performance_metric_val: float = 0.0
        , prediction_csv_path: str = ""
        , fit_config: str = ""
        , promotion: str = ""
        , promoted: bool = False
        , log_file_paths: Dict[str, str] = None
        , plot_files: Dict[str, str] = None
        , data_checks: DataChecks = None
        , credits_used: int = 0
        , model_query: str = ""
    , **kwargs) -> ModelVersion:
        self._attributes = dict()
        self.name = name
        self.model_version_id = model_version_id
        self.model_signature = model_signature
        self.experiment = experiment
        self.storage_uri = storage_uri
        self.model_version_format = model_version_format
        self.state = state
        self.error_message = error_message
        self.stack_trace = stack_trace
        self.system_time = system_time
        self.visible_start_time = visible_start_time
        self.visible_stop_time = visible_stop_time
        self.create_time = create_time
        self.update_time = update_time
        self.start_time = start_time
        self.end_time = end_time
        self.platform_version = platform_version
        self.training_row_count = training_row_count
        self.validation_row_count = validation_row_count
        self.test_row_count = test_row_count
        self.performance_metric = performance_metric
        self.performance_metric_val = performance_metric_val
        self.prediction_csv_path = prediction_csv_path
        self.fit_config = fit_config
        self.promotion = promotion
        self.promoted = promoted
        self.log_file_paths = log_file_paths
        self.plot_files = plot_files
        self.data_checks = data_checks
        self.credits_used = credits_used
        self.model_query = model_query

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "ModelVersion", "name", value, str, "")


    @property
    def model_version_id(self) -> int:
        """Model version id."""
        return self._attributes["model_version_id"]


    @model_version_id.setter
    def model_version_id(self, value: int) -> None:
        _set_attribute(self._attributes, "ModelVersion", "model_version_id", value, int, "")


    @property
    def model_signature(self) -> str:
        """Model signature."""
        return self._attributes["model_signature"]


    @model_signature.setter
    def model_signature(self, value: str) -> None:
        _set_attribute(self._attributes, "ModelVersion", "model_signature", value, str, "")


    @property
    def experiment(self) -> str:
        """Experiment."""
        return self._attributes["experiment"]


    @experiment.setter
    def experiment(self, value: str) -> None:
        _set_attribute(self._attributes, "ModelVersion", "experiment", value, str, "")


    @property
    def storage_uri(self) -> str:
        """Storage uri."""
        return self._attributes["storage_uri"]


    @storage_uri.setter
    def storage_uri(self, value: str) -> None:
        _set_attribute(self._attributes, "ModelVersion", "storage_uri", value, str, "")


    @property
    def model_version_format(self) -> str:
        """Model version format."""
        return self._attributes["model_version_format"]


    @model_version_format.setter
    def model_version_format(self, value: str) -> None:
        _set_attribute(self._attributes, "ModelVersion", "model_version_format", value, str, "")


    @property
    def state(self) -> ModelVersionState:
        """State."""
        return self._attributes["state"]


    @state.setter
    def state(self, value: ModelVersionState) -> None:
        _set_attribute(self._attributes, "ModelVersion", "state", value, ModelVersionState, "")


    @property
    def error_message(self) -> str:
        """Error message."""
        return self._attributes["error_message"]


    @error_message.setter
    def error_message(self, value: str) -> None:
        _set_attribute(self._attributes, "ModelVersion", "error_message", value, str, "")


    @property
    def stack_trace(self) -> str:
        """Stack trace."""
        return self._attributes["stack_trace"]


    @stack_trace.setter
    def stack_trace(self, value: str) -> None:
        _set_attribute(self._attributes, "ModelVersion", "stack_trace", value, str, "")


    @property
    def system_time(self) -> datetime:
        """System time."""
        return self._attributes["system_time"]


    @system_time.setter
    def system_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ModelVersion", "system_time", value, datetime, "")


    @property
    def visible_start_time(self) -> datetime:
        """Visible start time."""
        return self._attributes["visible_start_time"]


    @visible_start_time.setter
    def visible_start_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ModelVersion", "visible_start_time", value, datetime, "")


    @property
    def visible_stop_time(self) -> datetime:
        """Visible stop time."""
        return self._attributes["visible_stop_time"]


    @visible_stop_time.setter
    def visible_stop_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ModelVersion", "visible_stop_time", value, datetime, "")


    @property
    def create_time(self) -> datetime:
        """Create time."""
        return self._attributes["create_time"]


    @create_time.setter
    def create_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ModelVersion", "create_time", value, datetime, "")


    @property
    def update_time(self) -> datetime:
        """Update time."""
        return self._attributes["update_time"]


    @update_time.setter
    def update_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ModelVersion", "update_time", value, datetime, "")


    @property
    def start_time(self) -> datetime:
        """Start time."""
        return self._attributes["start_time"]


    @start_time.setter
    def start_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ModelVersion", "start_time", value, datetime, "")


    @property
    def end_time(self) -> datetime:
        """End time."""
        return self._attributes["end_time"]


    @end_time.setter
    def end_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ModelVersion", "end_time", value, datetime, "")


    @property
    def platform_version(self) -> str:
        """Platform version."""
        return self._attributes["platform_version"]


    @platform_version.setter
    def platform_version(self, value: str) -> None:
        _set_attribute(self._attributes, "ModelVersion", "platform_version", value, str, "")


    @property
    def training_row_count(self) -> int:
        """Training row count."""
        return self._attributes["training_row_count"]


    @training_row_count.setter
    def training_row_count(self, value: int) -> None:
        _set_attribute(self._attributes, "ModelVersion", "training_row_count", value, int, "")


    @property
    def validation_row_count(self) -> int:
        """Validation row count."""
        return self._attributes["validation_row_count"]


    @validation_row_count.setter
    def validation_row_count(self, value: int) -> None:
        _set_attribute(self._attributes, "ModelVersion", "validation_row_count", value, int, "")


    @property
    def test_row_count(self) -> int:
        """Test row count."""
        return self._attributes["test_row_count"]


    @test_row_count.setter
    def test_row_count(self, value: int) -> None:
        _set_attribute(self._attributes, "ModelVersion", "test_row_count", value, int, "")


    @property
    def performance_metric(self) -> str:
        """Performance metric."""
        return self._attributes["performance_metric"]


    @performance_metric.setter
    def performance_metric(self, value: str) -> None:
        _set_attribute(self._attributes, "ModelVersion", "performance_metric", value, str, "")


    @property
    def performance_metric_val(self) -> float:
        """Performance metric val."""
        return self._attributes["performance_metric_val"]


    @performance_metric_val.setter
    def performance_metric_val(self, value: float) -> None:
        _set_attribute(self._attributes, "ModelVersion", "performance_metric_val", value, float, "")


    @property
    def prediction_csv_path(self) -> str:
        """Prediction csv path."""
        return self._attributes["prediction_csv_path"]


    @prediction_csv_path.setter
    def prediction_csv_path(self, value: str) -> None:
        _set_attribute(self._attributes, "ModelVersion", "prediction_csv_path", value, str, "")


    @property
    def fit_config(self) -> str:
        """Fit config."""
        return self._attributes["fit_config"]


    @fit_config.setter
    def fit_config(self, value: str) -> None:
        _set_attribute(self._attributes, "ModelVersion", "fit_config", value, str, "")


    @property
    def promotion(self) -> str:
        """Promotion."""
        return self._attributes["promotion"]


    @promotion.setter
    def promotion(self, value: str) -> None:
        _set_attribute(self._attributes, "ModelVersion", "promotion", value, str, "")


    @property
    def promoted(self) -> bool:
        """Promoted."""
        return self._attributes["promoted"]


    @promoted.setter
    def promoted(self, value: bool) -> None:
        _set_attribute(self._attributes, "ModelVersion", "promoted", value, bool, "")


    @property
    def log_file_paths(self) -> Dict[str, str]:
        """Log file paths."""
        return self._attributes["log_file_paths"]


    @log_file_paths.setter
    def log_file_paths(self, value: Dict[str, str]) -> None:
        _set_attribute(self._attributes, "ModelVersion", "log_file_paths", value, Dict[str, str], "")


    @property
    def plot_files(self) -> Dict[str, str]:
        """Plot files."""
        return self._attributes["plot_files"]


    @plot_files.setter
    def plot_files(self, value: Dict[str, str]) -> None:
        _set_attribute(self._attributes, "ModelVersion", "plot_files", value, Dict[str, str], "")


    @property
    def data_checks(self) -> DataChecks:
        """Data checks."""
        return self._attributes["data_checks"]


    @data_checks.setter
    def data_checks(self, value: DataChecks) -> None:
        _set_attribute(self._attributes, "ModelVersion", "data_checks", value, DataChecks, "")


    @property
    def credits_used(self) -> int:
        """Credits used."""
        return self._attributes["credits_used"]


    @credits_used.setter
    def credits_used(self, value: int) -> None:
        _set_attribute(self._attributes, "ModelVersion", "credits_used", value, int, "")


    @property
    def model_query(self) -> str:
        """Model query."""
        return self._attributes["model_query"]


    @model_query.setter
    def model_query(self, value: str) -> None:
        _set_attribute(self._attributes, "ModelVersion", "model_query", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.ModelVersion, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.ModelVersion:
        """Convert object to proto representation."""
        return management_types_pb2.ModelVersion(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ModelVersion object " + repr(self.to_dict()) + ">"


class ConfusionMatrix:
    """Confusion matrix."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , display_name: List[str] = []
        , row: List[ConfusionMatrixRow] = []
    , **kwargs) -> ConfusionMatrix:
        self._attributes = dict()
        self.display_name = display_name
        self.row = row

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def display_name(self) -> List[str]:
        """Display name."""
        return self._attributes["display_name"]


    @display_name.setter
    def display_name(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ConfusionMatrix", "display_name", value, List[str], "")


    @property
    def row(self) -> List[ConfusionMatrixRow]:
        """Row."""
        return self._attributes["row"]


    @row.setter
    def row(self, value: List[ConfusionMatrixRow]) -> None:
        _set_attribute(self._attributes, "ConfusionMatrix", "row", value, List[ConfusionMatrixRow], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.ConfusionMatrix, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.ConfusionMatrix:
        """Convert object to proto representation."""
        return management_types_pb2.ConfusionMatrix(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ConfusionMatrix object " + repr(self.to_dict()) + ">"


class ConfusionMatrixRow:
    """Confusion matrix row."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , example_count: List[int] = []
    , **kwargs) -> ConfusionMatrixRow:
        self._attributes = dict()
        self.example_count = example_count

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def example_count(self) -> List[int]:
        """Example count."""
        return self._attributes["example_count"]


    @example_count.setter
    def example_count(self, value: List[int]) -> None:
        _set_attribute(self._attributes, "ConfusionMatrixRow", "example_count", value, List[int], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.ConfusionMatrix.Row, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.ConfusionMatrix.Row:
        """Convert object to proto representation."""
        return management_types_pb2.ConfusionMatrix.Row(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ConfusionMatrixRow object " + repr(self.to_dict()) + ">"


class BooleanEvaluationMetrics:
    """Boolean evaluation metrics."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , log_loss: float = 0.0
        , accuracy: float = 0.0
        , roc_auc: float = 0.0
        , error: float = 0.0
        , confusion_matrix: ConfusionMatrix = None
        , precision: float = 0.0
        , recall: float = 0.0
        , f1: float = 0.0
    , **kwargs) -> BooleanEvaluationMetrics:
        self._attributes = dict()
        self.log_loss = log_loss
        self.accuracy = accuracy
        self.roc_auc = roc_auc
        self.error = error
        self.confusion_matrix = confusion_matrix
        self.precision = precision
        self.recall = recall
        self.f1 = f1

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def log_loss(self) -> float:
        """Log loss."""
        return self._attributes["log_loss"]


    @log_loss.setter
    def log_loss(self, value: float) -> None:
        _set_attribute(self._attributes, "BooleanEvaluationMetrics", "log_loss", value, float, "")


    @property
    def accuracy(self) -> float:
        """Accuracy."""
        return self._attributes["accuracy"]


    @accuracy.setter
    def accuracy(self, value: float) -> None:
        _set_attribute(self._attributes, "BooleanEvaluationMetrics", "accuracy", value, float, "")


    @property
    def roc_auc(self) -> float:
        """Roc auc."""
        return self._attributes["roc_auc"]


    @roc_auc.setter
    def roc_auc(self, value: float) -> None:
        _set_attribute(self._attributes, "BooleanEvaluationMetrics", "roc_auc", value, float, "")


    @property
    def error(self) -> float:
        """Error."""
        return self._attributes["error"]


    @error.setter
    def error(self, value: float) -> None:
        _set_attribute(self._attributes, "BooleanEvaluationMetrics", "error", value, float, "")


    @property
    def confusion_matrix(self) -> ConfusionMatrix:
        """Confusion matrix."""
        return self._attributes["confusion_matrix"]


    @confusion_matrix.setter
    def confusion_matrix(self, value: ConfusionMatrix) -> None:
        _set_attribute(self._attributes, "BooleanEvaluationMetrics", "confusion_matrix", value, ConfusionMatrix, "")


    @property
    def precision(self) -> float:
        """Precision."""
        return self._attributes["precision"]


    @precision.setter
    def precision(self, value: float) -> None:
        _set_attribute(self._attributes, "BooleanEvaluationMetrics", "precision", value, float, "")


    @property
    def recall(self) -> float:
        """Recall."""
        return self._attributes["recall"]


    @recall.setter
    def recall(self, value: float) -> None:
        _set_attribute(self._attributes, "BooleanEvaluationMetrics", "recall", value, float, "")


    @property
    def f1(self) -> float:
        """F1."""
        return self._attributes["f1"]


    @f1.setter
    def f1(self, value: float) -> None:
        _set_attribute(self._attributes, "BooleanEvaluationMetrics", "f1", value, float, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.BooleanEvaluationMetrics, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.BooleanEvaluationMetrics:
        """Convert object to proto representation."""
        return management_types_pb2.BooleanEvaluationMetrics(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BooleanEvaluationMetrics object " + repr(self.to_dict()) + ">"


class TextEvaluationMetrics:
    """Text evaluation metrics."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , log_loss: float = 0.0
        , f1: float = 0.0
        , perplexity: float = 0.0
        , edit_distance: float = 0.0
        , token_accuracy: float = 0.0
        , bleu: float = 0.0
    , **kwargs) -> TextEvaluationMetrics:
        self._attributes = dict()
        self.log_loss = log_loss
        self.f1 = f1
        self.perplexity = perplexity
        self.edit_distance = edit_distance
        self.token_accuracy = token_accuracy
        self.bleu = bleu

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def log_loss(self) -> float:
        """Log loss."""
        return self._attributes["log_loss"]


    @log_loss.setter
    def log_loss(self, value: float) -> None:
        _set_attribute(self._attributes, "TextEvaluationMetrics", "log_loss", value, float, "")


    @property
    def f1(self) -> float:
        """F1."""
        return self._attributes["f1"]


    @f1.setter
    def f1(self, value: float) -> None:
        _set_attribute(self._attributes, "TextEvaluationMetrics", "f1", value, float, "")


    @property
    def perplexity(self) -> float:
        """Perplexity."""
        return self._attributes["perplexity"]


    @perplexity.setter
    def perplexity(self, value: float) -> None:
        _set_attribute(self._attributes, "TextEvaluationMetrics", "perplexity", value, float, "")


    @property
    def edit_distance(self) -> float:
        """Edit distance."""
        return self._attributes["edit_distance"]


    @edit_distance.setter
    def edit_distance(self, value: float) -> None:
        _set_attribute(self._attributes, "TextEvaluationMetrics", "edit_distance", value, float, "")


    @property
    def token_accuracy(self) -> float:
        """Token accuracy."""
        return self._attributes["token_accuracy"]


    @token_accuracy.setter
    def token_accuracy(self, value: float) -> None:
        _set_attribute(self._attributes, "TextEvaluationMetrics", "token_accuracy", value, float, "")


    @property
    def bleu(self) -> float:
        """Bleu."""
        return self._attributes["bleu"]


    @bleu.setter
    def bleu(self, value: float) -> None:
        _set_attribute(self._attributes, "TextEvaluationMetrics", "bleu", value, float, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.TextEvaluationMetrics, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.TextEvaluationMetrics:
        """Convert object to proto representation."""
        return management_types_pb2.TextEvaluationMetrics(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<TextEvaluationMetrics object " + repr(self.to_dict()) + ">"


class CategoricalEvaluationMetrics:
    """Categorical evaluation metrics."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , log_loss: float = 0.0
        , accuracy: float = 0.0
        , roc_auc: float = 0.0
        , multiclass_error: float = 0.0
        , confusion_matrix: ConfusionMatrix = None
        , precision: float = 0.0
        , precision_micro: float = 0.0
        , precision_macro: float = 0.0
        , precision_weighted: float = 0.0
        , recall: float = 0.0
        , recall_micro: float = 0.0
        , recall_macro: float = 0.0
        , recall_weighted: float = 0.0
        , f1: float = 0.0
        , f1_micro: float = 0.0
        , f1_macro: float = 0.0
        , f1_weighted: float = 0.0
        , balanced_accuracy: float = 0.0
        , average_precision: float = 0.0
    , **kwargs) -> CategoricalEvaluationMetrics:
        self._attributes = dict()
        self.log_loss = log_loss
        self.accuracy = accuracy
        self.roc_auc = roc_auc
        self.multiclass_error = multiclass_error
        self.confusion_matrix = confusion_matrix
        self.precision = precision
        self.precision_micro = precision_micro
        self.precision_macro = precision_macro
        self.precision_weighted = precision_weighted
        self.recall = recall
        self.recall_micro = recall_micro
        self.recall_macro = recall_macro
        self.recall_weighted = recall_weighted
        self.f1 = f1
        self.f1_micro = f1_micro
        self.f1_macro = f1_macro
        self.f1_weighted = f1_weighted
        self.balanced_accuracy = balanced_accuracy
        self.average_precision = average_precision

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def log_loss(self) -> float:
        """Log loss."""
        return self._attributes["log_loss"]


    @log_loss.setter
    def log_loss(self, value: float) -> None:
        _set_attribute(self._attributes, "CategoricalEvaluationMetrics", "log_loss", value, float, "")


    @property
    def accuracy(self) -> float:
        """Accuracy."""
        return self._attributes["accuracy"]


    @accuracy.setter
    def accuracy(self, value: float) -> None:
        _set_attribute(self._attributes, "CategoricalEvaluationMetrics", "accuracy", value, float, "")


    @property
    def roc_auc(self) -> float:
        """Roc auc."""
        return self._attributes["roc_auc"]


    @roc_auc.setter
    def roc_auc(self, value: float) -> None:
        _set_attribute(self._attributes, "CategoricalEvaluationMetrics", "roc_auc", value, float, "")


    @property
    def multiclass_error(self) -> float:
        """Multiclass error."""
        return self._attributes["multiclass_error"]


    @multiclass_error.setter
    def multiclass_error(self, value: float) -> None:
        _set_attribute(self._attributes, "CategoricalEvaluationMetrics", "multiclass_error", value, float, "")


    @property
    def confusion_matrix(self) -> ConfusionMatrix:
        """Confusion matrix."""
        return self._attributes["confusion_matrix"]


    @confusion_matrix.setter
    def confusion_matrix(self, value: ConfusionMatrix) -> None:
        _set_attribute(self._attributes, "CategoricalEvaluationMetrics", "confusion_matrix", value, ConfusionMatrix, "")


    @property
    def precision(self) -> float:
        """Precision."""
        return self._attributes["precision"]


    @precision.setter
    def precision(self, value: float) -> None:
        _set_attribute(self._attributes, "CategoricalEvaluationMetrics", "precision", value, float, "")


    @property
    def precision_micro(self) -> float:
        """Precision micro."""
        return self._attributes["precision_micro"]


    @precision_micro.setter
    def precision_micro(self, value: float) -> None:
        _set_attribute(self._attributes, "CategoricalEvaluationMetrics", "precision_micro", value, float, "")


    @property
    def precision_macro(self) -> float:
        """Precision macro."""
        return self._attributes["precision_macro"]


    @precision_macro.setter
    def precision_macro(self, value: float) -> None:
        _set_attribute(self._attributes, "CategoricalEvaluationMetrics", "precision_macro", value, float, "")


    @property
    def precision_weighted(self) -> float:
        """Precision weighted."""
        return self._attributes["precision_weighted"]


    @precision_weighted.setter
    def precision_weighted(self, value: float) -> None:
        _set_attribute(self._attributes, "CategoricalEvaluationMetrics", "precision_weighted", value, float, "")


    @property
    def recall(self) -> float:
        """Recall."""
        return self._attributes["recall"]


    @recall.setter
    def recall(self, value: float) -> None:
        _set_attribute(self._attributes, "CategoricalEvaluationMetrics", "recall", value, float, "")


    @property
    def recall_micro(self) -> float:
        """Recall micro."""
        return self._attributes["recall_micro"]


    @recall_micro.setter
    def recall_micro(self, value: float) -> None:
        _set_attribute(self._attributes, "CategoricalEvaluationMetrics", "recall_micro", value, float, "")


    @property
    def recall_macro(self) -> float:
        """Recall macro."""
        return self._attributes["recall_macro"]


    @recall_macro.setter
    def recall_macro(self, value: float) -> None:
        _set_attribute(self._attributes, "CategoricalEvaluationMetrics", "recall_macro", value, float, "")


    @property
    def recall_weighted(self) -> float:
        """Recall weighted."""
        return self._attributes["recall_weighted"]


    @recall_weighted.setter
    def recall_weighted(self, value: float) -> None:
        _set_attribute(self._attributes, "CategoricalEvaluationMetrics", "recall_weighted", value, float, "")


    @property
    def f1(self) -> float:
        """F1."""
        return self._attributes["f1"]


    @f1.setter
    def f1(self, value: float) -> None:
        _set_attribute(self._attributes, "CategoricalEvaluationMetrics", "f1", value, float, "")


    @property
    def f1_micro(self) -> float:
        """F1 micro."""
        return self._attributes["f1_micro"]


    @f1_micro.setter
    def f1_micro(self, value: float) -> None:
        _set_attribute(self._attributes, "CategoricalEvaluationMetrics", "f1_micro", value, float, "")


    @property
    def f1_macro(self) -> float:
        """F1 macro."""
        return self._attributes["f1_macro"]


    @f1_macro.setter
    def f1_macro(self, value: float) -> None:
        _set_attribute(self._attributes, "CategoricalEvaluationMetrics", "f1_macro", value, float, "")


    @property
    def f1_weighted(self) -> float:
        """F1 weighted."""
        return self._attributes["f1_weighted"]


    @f1_weighted.setter
    def f1_weighted(self, value: float) -> None:
        _set_attribute(self._attributes, "CategoricalEvaluationMetrics", "f1_weighted", value, float, "")


    @property
    def balanced_accuracy(self) -> float:
        """Balanced accuracy."""
        return self._attributes["balanced_accuracy"]


    @balanced_accuracy.setter
    def balanced_accuracy(self, value: float) -> None:
        _set_attribute(self._attributes, "CategoricalEvaluationMetrics", "balanced_accuracy", value, float, "")


    @property
    def average_precision(self) -> float:
        """Average precision."""
        return self._attributes["average_precision"]


    @average_precision.setter
    def average_precision(self, value: float) -> None:
        _set_attribute(self._attributes, "CategoricalEvaluationMetrics", "average_precision", value, float, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.CategoricalEvaluationMetrics, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.CategoricalEvaluationMetrics:
        """Convert object to proto representation."""
        return management_types_pb2.CategoricalEvaluationMetrics(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<CategoricalEvaluationMetrics object " + repr(self.to_dict()) + ">"


class NumberEvaluationMetrics:
    """Number evaluation metrics."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , rmse: float = 0.0
        , mae: float = 0.0
        , r2: float = 0.0
        , precision: float = 0.0
        , recall: float = 0.0
        , mape: float = 0.0
        , smape: float = 0.0
        , mean_squared_error: float = 0.0
        , median_absolute_error: float = 0.0
    , **kwargs) -> NumberEvaluationMetrics:
        self._attributes = dict()
        self.rmse = rmse
        self.mae = mae
        self.r2 = r2
        self.precision = precision
        self.recall = recall
        self.mape = mape
        self.smape = smape
        self.mean_squared_error = mean_squared_error
        self.median_absolute_error = median_absolute_error

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def rmse(self) -> float:
        """Rmse."""
        return self._attributes["rmse"]


    @rmse.setter
    def rmse(self, value: float) -> None:
        _set_attribute(self._attributes, "NumberEvaluationMetrics", "rmse", value, float, "")


    @property
    def mae(self) -> float:
        """Mae."""
        return self._attributes["mae"]


    @mae.setter
    def mae(self, value: float) -> None:
        _set_attribute(self._attributes, "NumberEvaluationMetrics", "mae", value, float, "")


    @property
    def r2(self) -> float:
        """R2."""
        return self._attributes["r2"]


    @r2.setter
    def r2(self, value: float) -> None:
        _set_attribute(self._attributes, "NumberEvaluationMetrics", "r2", value, float, "")


    @property
    def precision(self) -> float:
        """Precision."""
        return self._attributes["precision"]


    @precision.setter
    def precision(self, value: float) -> None:
        _set_attribute(self._attributes, "NumberEvaluationMetrics", "precision", value, float, "")


    @property
    def recall(self) -> float:
        """Recall."""
        return self._attributes["recall"]


    @recall.setter
    def recall(self, value: float) -> None:
        _set_attribute(self._attributes, "NumberEvaluationMetrics", "recall", value, float, "")


    @property
    def mape(self) -> float:
        """Mape."""
        return self._attributes["mape"]


    @mape.setter
    def mape(self, value: float) -> None:
        _set_attribute(self._attributes, "NumberEvaluationMetrics", "mape", value, float, "")


    @property
    def smape(self) -> float:
        """Smape."""
        return self._attributes["smape"]


    @smape.setter
    def smape(self, value: float) -> None:
        _set_attribute(self._attributes, "NumberEvaluationMetrics", "smape", value, float, "")


    @property
    def mean_squared_error(self) -> float:
        """Mean squared error."""
        return self._attributes["mean_squared_error"]


    @mean_squared_error.setter
    def mean_squared_error(self, value: float) -> None:
        _set_attribute(self._attributes, "NumberEvaluationMetrics", "mean_squared_error", value, float, "")


    @property
    def median_absolute_error(self) -> float:
        """Median absolute error."""
        return self._attributes["median_absolute_error"]


    @median_absolute_error.setter
    def median_absolute_error(self, value: float) -> None:
        _set_attribute(self._attributes, "NumberEvaluationMetrics", "median_absolute_error", value, float, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.NumberEvaluationMetrics, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.NumberEvaluationMetrics:
        """Convert object to proto representation."""
        return management_types_pb2.NumberEvaluationMetrics(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<NumberEvaluationMetrics object " + repr(self.to_dict()) + ">"


class EvaluationMetrics:
    """Evaluation metrics."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , boolean: BooleanEvaluationMetrics = None
        , number: NumberEvaluationMetrics = None
        , text: TextEvaluationMetrics = None
        , categorical: CategoricalEvaluationMetrics = None
    , **kwargs) -> EvaluationMetrics:
        self._attributes = dict()
        self.boolean = boolean
        self.number = number
        self.text = text
        self.categorical = categorical

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def boolean(self) -> BooleanEvaluationMetrics:
        """Boolean."""
        return self._attributes["boolean"]


    @boolean.setter
    def boolean(self, value: BooleanEvaluationMetrics) -> None:
        _set_attribute(self._attributes, "EvaluationMetrics", "boolean", value, BooleanEvaluationMetrics, "metrics")


    @property
    def number(self) -> NumberEvaluationMetrics:
        """Number."""
        return self._attributes["number"]


    @number.setter
    def number(self, value: NumberEvaluationMetrics) -> None:
        _set_attribute(self._attributes, "EvaluationMetrics", "number", value, NumberEvaluationMetrics, "metrics")


    @property
    def text(self) -> TextEvaluationMetrics:
        """Text."""
        return self._attributes["text"]


    @text.setter
    def text(self, value: TextEvaluationMetrics) -> None:
        _set_attribute(self._attributes, "EvaluationMetrics", "text", value, TextEvaluationMetrics, "metrics")


    @property
    def categorical(self) -> CategoricalEvaluationMetrics:
        """Categorical."""
        return self._attributes["categorical"]


    @categorical.setter
    def categorical(self, value: CategoricalEvaluationMetrics) -> None:
        _set_attribute(self._attributes, "EvaluationMetrics", "categorical", value, CategoricalEvaluationMetrics, "metrics")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.EvaluationMetrics, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.EvaluationMetrics:
        """Convert object to proto representation."""
        return management_types_pb2.EvaluationMetrics(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<EvaluationMetrics object " + repr(self.to_dict()) + ">"


class Metrics:
    """Metrics."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , train_metrics: EvaluationMetrics = None
        , validation_metrics: EvaluationMetrics = None
        , test_metrics: EvaluationMetrics = None
    , **kwargs) -> Metrics:
        self._attributes = dict()
        self.train_metrics = train_metrics
        self.validation_metrics = validation_metrics
        self.test_metrics = test_metrics

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def train_metrics(self) -> EvaluationMetrics:
        """Train metrics."""
        return self._attributes["train_metrics"]


    @train_metrics.setter
    def train_metrics(self, value: EvaluationMetrics) -> None:
        _set_attribute(self._attributes, "Metrics", "train_metrics", value, EvaluationMetrics, "")


    @property
    def validation_metrics(self) -> EvaluationMetrics:
        """Validation metrics."""
        return self._attributes["validation_metrics"]


    @validation_metrics.setter
    def validation_metrics(self, value: EvaluationMetrics) -> None:
        _set_attribute(self._attributes, "Metrics", "validation_metrics", value, EvaluationMetrics, "")


    @property
    def test_metrics(self) -> EvaluationMetrics:
        """Test metrics."""
        return self._attributes["test_metrics"]


    @test_metrics.setter
    def test_metrics(self, value: EvaluationMetrics) -> None:
        _set_attribute(self._attributes, "Metrics", "test_metrics", value, EvaluationMetrics, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.Metrics, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.Metrics:
        """Convert object to proto representation."""
        return management_types_pb2.Metrics(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<Metrics object " + repr(self.to_dict()) + ">"


class Experiment:
    """Experiment."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , display_name: str = ""
        , description: str = ""
        , type: str = ""
        , algorithm: str = ""
        , state: ExperimentState = 0
        , create_time: datetime = None
        , start_time: datetime = None
        , finish_time: datetime = None
        , performance_metric: str = ""
        , performance_metric_val: float = 0.0
        , metrics: Metrics = None
        , model_type: FieldType = 0
        , feature_importance: Dict[str, float] = None
        , training_config: str = ""
        , error_message: str = ""
        , stack_trace: str = ""
        , feature_importance_relative: Dict[str, float] = None
    , **kwargs) -> Experiment:
        self._attributes = dict()
        self.name = name
        self.display_name = display_name
        self.description = description
        self.type = type
        self.algorithm = algorithm
        self.state = state
        self.create_time = create_time
        self.start_time = start_time
        self.finish_time = finish_time
        self.performance_metric = performance_metric
        self.performance_metric_val = performance_metric_val
        self.metrics = metrics
        self.model_type = model_type
        self.feature_importance = feature_importance
        self.training_config = training_config
        self.error_message = error_message
        self.stack_trace = stack_trace
        self.feature_importance_relative = feature_importance_relative

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "Experiment", "name", value, str, "")


    @property
    def display_name(self) -> str:
        """Display name."""
        return self._attributes["display_name"]


    @display_name.setter
    def display_name(self, value: str) -> None:
        _set_attribute(self._attributes, "Experiment", "display_name", value, str, "")


    @property
    def description(self) -> str:
        """Description."""
        return self._attributes["description"]


    @description.setter
    def description(self, value: str) -> None:
        _set_attribute(self._attributes, "Experiment", "description", value, str, "")


    @property
    def type(self) -> str:
        """Type."""
        return self._attributes["type"]


    @type.setter
    def type(self, value: str) -> None:
        _set_attribute(self._attributes, "Experiment", "type", value, str, "")


    @property
    def algorithm(self) -> str:
        """Algorithm."""
        return self._attributes["algorithm"]


    @algorithm.setter
    def algorithm(self, value: str) -> None:
        _set_attribute(self._attributes, "Experiment", "algorithm", value, str, "")


    @property
    def state(self) -> ExperimentState:
        """State."""
        return self._attributes["state"]


    @state.setter
    def state(self, value: ExperimentState) -> None:
        _set_attribute(self._attributes, "Experiment", "state", value, ExperimentState, "")


    @property
    def create_time(self) -> datetime:
        """Create time."""
        return self._attributes["create_time"]


    @create_time.setter
    def create_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Experiment", "create_time", value, datetime, "")


    @property
    def start_time(self) -> datetime:
        """Start time."""
        return self._attributes["start_time"]


    @start_time.setter
    def start_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Experiment", "start_time", value, datetime, "")


    @property
    def finish_time(self) -> datetime:
        """Finish time."""
        return self._attributes["finish_time"]


    @finish_time.setter
    def finish_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Experiment", "finish_time", value, datetime, "")


    @property
    def performance_metric(self) -> str:
        """Performance metric."""
        return self._attributes["performance_metric"]


    @performance_metric.setter
    def performance_metric(self, value: str) -> None:
        _set_attribute(self._attributes, "Experiment", "performance_metric", value, str, "")


    @property
    def performance_metric_val(self) -> float:
        """Performance metric val."""
        return self._attributes["performance_metric_val"]


    @performance_metric_val.setter
    def performance_metric_val(self, value: float) -> None:
        _set_attribute(self._attributes, "Experiment", "performance_metric_val", value, float, "")


    @property
    def metrics(self) -> Metrics:
        """Metrics."""
        return self._attributes["metrics"]


    @metrics.setter
    def metrics(self, value: Metrics) -> None:
        _set_attribute(self._attributes, "Experiment", "metrics", value, Metrics, "")


    @property
    def model_type(self) -> FieldType:
        """Model type."""
        return self._attributes["model_type"]


    @model_type.setter
    def model_type(self, value: FieldType) -> None:
        _set_attribute(self._attributes, "Experiment", "model_type", value, FieldType, "")


    @property
    def feature_importance(self) -> Dict[str, float]:
        """Feature importance."""
        return self._attributes["feature_importance"]


    @feature_importance.setter
    def feature_importance(self, value: Dict[str, float]) -> None:
        _set_attribute(self._attributes, "Experiment", "feature_importance", value, Dict[str, float], "")


    @property
    def training_config(self) -> str:
        """Training config."""
        return self._attributes["training_config"]


    @training_config.setter
    def training_config(self, value: str) -> None:
        _set_attribute(self._attributes, "Experiment", "training_config", value, str, "")


    @property
    def error_message(self) -> str:
        """Error message."""
        return self._attributes["error_message"]


    @error_message.setter
    def error_message(self, value: str) -> None:
        _set_attribute(self._attributes, "Experiment", "error_message", value, str, "")


    @property
    def stack_trace(self) -> str:
        """Stack trace."""
        return self._attributes["stack_trace"]


    @stack_trace.setter
    def stack_trace(self, value: str) -> None:
        _set_attribute(self._attributes, "Experiment", "stack_trace", value, str, "")


    @property
    def feature_importance_relative(self) -> Dict[str, float]:
        """Feature importance relative."""
        return self._attributes["feature_importance_relative"]


    @feature_importance_relative.setter
    def feature_importance_relative(self, value: Dict[str, float]) -> None:
        _set_attribute(self._attributes, "Experiment", "feature_importance_relative", value, Dict[str, float], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.Experiment, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.Experiment:
        """Convert object to proto representation."""
        return management_types_pb2.Experiment(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<Experiment object " + repr(self.to_dict()) + ">"


class TrainingMetrics:
    """Training metrics."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , experiment: str = ""
        , step: int = 0
        , trainer: str = ""
        , capture_time: datetime = None
        , metric_type: FieldType = 0
        , metrics: Metrics = None
    , **kwargs) -> TrainingMetrics:
        self._attributes = dict()
        self.experiment = experiment
        self.step = step
        self.trainer = trainer
        self.capture_time = capture_time
        self.metric_type = metric_type
        self.metrics = metrics

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def experiment(self) -> str:
        """Experiment."""
        return self._attributes["experiment"]


    @experiment.setter
    def experiment(self, value: str) -> None:
        _set_attribute(self._attributes, "TrainingMetrics", "experiment", value, str, "")


    @property
    def step(self) -> int:
        """Step."""
        return self._attributes["step"]


    @step.setter
    def step(self, value: int) -> None:
        _set_attribute(self._attributes, "TrainingMetrics", "step", value, int, "")


    @property
    def trainer(self) -> str:
        """Trainer."""
        return self._attributes["trainer"]


    @trainer.setter
    def trainer(self, value: str) -> None:
        _set_attribute(self._attributes, "TrainingMetrics", "trainer", value, str, "")


    @property
    def capture_time(self) -> datetime:
        """Capture time."""
        return self._attributes["capture_time"]


    @capture_time.setter
    def capture_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "TrainingMetrics", "capture_time", value, datetime, "")


    @property
    def metric_type(self) -> FieldType:
        """Metric type."""
        return self._attributes["metric_type"]


    @metric_type.setter
    def metric_type(self, value: FieldType) -> None:
        _set_attribute(self._attributes, "TrainingMetrics", "metric_type", value, FieldType, "")


    @property
    def metrics(self) -> Metrics:
        """Metrics."""
        return self._attributes["metrics"]


    @metrics.setter
    def metrics(self, value: Metrics) -> None:
        _set_attribute(self._attributes, "TrainingMetrics", "metrics", value, Metrics, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.TrainingMetrics, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.TrainingMetrics:
        """Convert object to proto representation."""
        return management_types_pb2.TrainingMetrics(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<TrainingMetrics object " + repr(self.to_dict()) + ">"


class Metric:
    """Metric."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , time: datetime = None
        , value: float = 0.0
        , values: List[float] = []
    , **kwargs) -> Metric:
        self._attributes = dict()
        self.time = time
        self.value = value
        self.values = values

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def time(self) -> datetime:
        """https://prometheus.io/docs/prometheus/latest/querying/api/#expression-query-result-formats
 NaN, Inf, -Inf will be removed from the results
 Metric time."""
        return self._attributes["time"]


    @time.setter
    def time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Metric", "time", value, datetime, "")


    @property
    def value(self) -> float:
        """Single value metrics."""
        return self._attributes["value"]


    @value.setter
    def value(self, value: float) -> None:
        _set_attribute(self._attributes, "Metric", "value", value, float, "")


    @property
    def values(self) -> List[float]:
        """Array metrics, such as histograms.
 Histogram: 1, 5, 10, 25, 50, 75, 90, 85, 99"""
        return self._attributes["values"]


    @values.setter
    def values(self, value: List[float]) -> None:
        _set_attribute(self._attributes, "Metric", "values", value, List[float], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.Metric, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.Metric:
        """Convert object to proto representation."""
        return management_types_pb2.Metric(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<Metric object " + repr(self.to_dict()) + ">"


class BatchPredictionMetric:
    """Batch prediction metric."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , start_time: datetime = None
        , end_time: datetime = None
        , prediction_count: int = 0
        , success: bool = False
        , error_code: str = ""
    , **kwargs) -> BatchPredictionMetric:
        self._attributes = dict()
        self.name = name
        self.start_time = start_time
        self.end_time = end_time
        self.prediction_count = prediction_count
        self.success = success
        self.error_code = error_code

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """the name of the batch prediction job so it can be linked"""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "BatchPredictionMetric", "name", value, str, "")


    @property
    def start_time(self) -> datetime:
        """the start and end time for the job
 charts can use either or both or use to compute average times"""
        return self._attributes["start_time"]


    @start_time.setter
    def start_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "BatchPredictionMetric", "start_time", value, datetime, "")


    @property
    def end_time(self) -> datetime:
        """End time."""
        return self._attributes["end_time"]


    @end_time.setter
    def end_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "BatchPredictionMetric", "end_time", value, datetime, "")


    @property
    def prediction_count(self) -> int:
        """the number of predictions made by the job"""
        return self._attributes["prediction_count"]


    @prediction_count.setter
    def prediction_count(self, value: int) -> None:
        _set_attribute(self._attributes, "BatchPredictionMetric", "prediction_count", value, int, "")


    @property
    def success(self) -> bool:
        """Success."""
        return self._attributes["success"]


    @success.setter
    def success(self, value: bool) -> None:
        _set_attribute(self._attributes, "BatchPredictionMetric", "success", value, bool, "")


    @property
    def error_code(self) -> str:
        """if the job failed, the error code so a chart can display if an error occured"""
        return self._attributes["error_code"]


    @error_code.setter
    def error_code(self, value: str) -> None:
        _set_attribute(self._attributes, "BatchPredictionMetric", "error_code", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.BatchPredictionMetric, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.BatchPredictionMetric:
        """Convert object to proto representation."""
        return management_types_pb2.BatchPredictionMetric(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchPredictionMetric object " + repr(self.to_dict()) + ">"


class TextSequence:
    """Text sequence."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , value: List[str] = []
    , **kwargs) -> TextSequence:
        self._attributes = dict()
        self.value = value

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def value(self) -> List[str]:
        """Value."""
        return self._attributes["value"]


    @value.setter
    def value(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "TextSequence", "value", value, List[str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.TextSequence, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.TextSequence:
        """Convert object to proto representation."""
        return management_types_pb2.TextSequence(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<TextSequence object " + repr(self.to_dict()) + ">"


class NumberSequence:
    """Number sequence."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , value: List[float] = []
    , **kwargs) -> NumberSequence:
        self._attributes = dict()
        self.value = value

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def value(self) -> List[float]:
        """Value."""
        return self._attributes["value"]


    @value.setter
    def value(self, value: List[float]) -> None:
        _set_attribute(self._attributes, "NumberSequence", "value", value, List[float], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.NumberSequence, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.NumberSequence:
        """Convert object to proto representation."""
        return management_types_pb2.NumberSequence(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<NumberSequence object " + repr(self.to_dict()) + ">"


class SignatureFeature:
    """Signature feature."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , qualified_name: str = ""
        , type: FieldType = 0
    , **kwargs) -> SignatureFeature:
        self._attributes = dict()
        self.qualified_name = qualified_name
        self.type = type

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def qualified_name(self) -> str:
        """Qualified name."""
        return self._attributes["qualified_name"]


    @qualified_name.setter
    def qualified_name(self, value: str) -> None:
        _set_attribute(self._attributes, "SignatureFeature", "qualified_name", value, str, "")


    @property
    def type(self) -> FieldType:
        """Type."""
        return self._attributes["type"]


    @type.setter
    def type(self, value: FieldType) -> None:
        _set_attribute(self._attributes, "SignatureFeature", "type", value, FieldType, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.SignatureFeature, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.SignatureFeature:
        """Convert object to proto representation."""
        return management_types_pb2.SignatureFeature(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<SignatureFeature object " + repr(self.to_dict()) + ">"


class QueryFeature:
    """Query feature."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , qualified_name: str = ""
        , relation: Query = None
        , value: str = ""
        , type: FieldType = 0
        , dtype: str = ""
        , model: bool = False
        , index: bool = False
        , time_index: bool = False
        , exclude: bool = False
        , split: bool = False
    , **kwargs) -> QueryFeature:
        self._attributes = dict()
        self.name = name
        self.qualified_name = qualified_name
        self.relation = relation
        self.value = value
        self.type = type
        self.dtype = dtype
        self.model = model
        self.index = index
        self.time_index = time_index
        self.exclude = exclude
        self.split = split

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name of the field to query"""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "QueryFeature", "name", value, str, "")


    @property
    def qualified_name(self) -> str:
        """Fully qualified name of the field"""
        return self._attributes["qualified_name"]


    @qualified_name.setter
    def qualified_name(self, value: str) -> None:
        _set_attribute(self._attributes, "QueryFeature", "qualified_name", value, str, "")


    @property
    def relation(self) -> Query:
        """fields from linked featureset if this field represents a relation."""
        return self._attributes["relation"]


    @relation.setter
    def relation(self, value: Query) -> None:
        _set_attribute(self._attributes, "QueryFeature", "relation", value, Query, "")


    @property
    def value(self) -> str:
        """Value of the field to be returned as an override."""
        return self._attributes["value"]


    @value.setter
    def value(self, value: str) -> None:
        _set_attribute(self._attributes, "QueryFeature", "value", value, str, "")


    @property
    def type(self) -> FieldType:
        """Type."""
        return self._attributes["type"]


    @type.setter
    def type(self, value: FieldType) -> None:
        _set_attribute(self._attributes, "QueryFeature", "type", value, FieldType, "")


    @property
    def dtype(self) -> str:
        """Dtype."""
        return self._attributes["dtype"]


    @dtype.setter
    def dtype(self, value: str) -> None:
        _set_attribute(self._attributes, "QueryFeature", "dtype", value, str, "")


    @property
    def model(self) -> bool:
        """Is this field a model"""
        return self._attributes["model"]


    @model.setter
    def model(self, value: bool) -> None:
        _set_attribute(self._attributes, "QueryFeature", "model", value, bool, "")


    @property
    def index(self) -> bool:
        """Index."""
        return self._attributes["index"]


    @index.setter
    def index(self, value: bool) -> None:
        _set_attribute(self._attributes, "QueryFeature", "index", value, bool, "")


    @property
    def time_index(self) -> bool:
        """Time index."""
        return self._attributes["time_index"]


    @time_index.setter
    def time_index(self, value: bool) -> None:
        _set_attribute(self._attributes, "QueryFeature", "time_index", value, bool, "")


    @property
    def exclude(self) -> bool:
        """Exclude this column from training."""
        return self._attributes["exclude"]


    @exclude.setter
    def exclude(self, value: bool) -> None:
        _set_attribute(self._attributes, "QueryFeature", "exclude", value, bool, "")


    @property
    def split(self) -> bool:
        """If this a split feature."""
        return self._attributes["split"]


    @split.setter
    def split(self, value: bool) -> None:
        _set_attribute(self._attributes, "QueryFeature", "split", value, bool, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.QueryFeature, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.QueryFeature:
        """Convert object to proto representation."""
        return management_types_pb2.QueryFeature(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<QueryFeature object " + repr(self.to_dict()) + ">"


class Query:
    """Query format for requesting data using get_training_data and get_serving_data"""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , entity_id: str = ""
        , table_name: str = ""
        , fields: List[QueryFeature] = []
        , related: List[Query] = []
    , **kwargs) -> Query:
        self._attributes = dict()
        self.name = name
        self.entity_id = entity_id
        self.table_name = table_name
        self.fields = fields
        self.related = related

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """object name to query"""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "Query", "name", value, str, "")


    @property
    def entity_id(self) -> str:
        """Entity this featureset is part of"""
        return self._attributes["entity_id"]


    @entity_id.setter
    def entity_id(self, value: str) -> None:
        _set_attribute(self._attributes, "Query", "entity_id", value, str, "")


    @property
    def table_name(self) -> str:
        """Table name config for the object"""
        return self._attributes["table_name"]


    @table_name.setter
    def table_name(self, value: str) -> None:
        _set_attribute(self._attributes, "Query", "table_name", value, str, "")


    @property
    def fields(self) -> List[QueryFeature]:
        """Fields to query"""
        return self._attributes["fields"]


    @fields.setter
    def fields(self, value: List[QueryFeature]) -> None:
        _set_attribute(self._attributes, "Query", "fields", value, List[QueryFeature], "")


    @property
    def related(self) -> List[Query]:
        """Related featuresets to include in the request"""
        return self._attributes["related"]


    @related.setter
    def related(self, value: List[Query]) -> None:
        _set_attribute(self._attributes, "Query", "related", value, List[Query], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.Query, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.Query:
        """Convert object to proto representation."""
        return management_types_pb2.Query(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<Query object " + repr(self.to_dict()) + ">"


class ChangeSummary:
    """Change summary."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , models_added: List[str] = []
        , models_modified: List[str] = []
        , models_deleted: List[str] = []
        , model_versions_trained: List[str] = []
        , feature_sets_added: List[str] = []
        , feature_sets_modified: List[str] = []
        , feature_sets_deleted: List[str] = []
        , features_added: List[str] = []
        , features_deleted: List[str] = []
        , predictions_made: int = 0
    , **kwargs) -> ChangeSummary:
        self._attributes = dict()
        self.models_added = models_added
        self.models_modified = models_modified
        self.models_deleted = models_deleted
        self.model_versions_trained = model_versions_trained
        self.feature_sets_added = feature_sets_added
        self.feature_sets_modified = feature_sets_modified
        self.feature_sets_deleted = feature_sets_deleted
        self.features_added = features_added
        self.features_deleted = features_deleted
        self.predictions_made = predictions_made

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def models_added(self) -> List[str]:
        """Models added."""
        return self._attributes["models_added"]


    @models_added.setter
    def models_added(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ChangeSummary", "models_added", value, List[str], "")


    @property
    def models_modified(self) -> List[str]:
        """Models modified."""
        return self._attributes["models_modified"]


    @models_modified.setter
    def models_modified(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ChangeSummary", "models_modified", value, List[str], "")


    @property
    def models_deleted(self) -> List[str]:
        """Models deleted."""
        return self._attributes["models_deleted"]


    @models_deleted.setter
    def models_deleted(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ChangeSummary", "models_deleted", value, List[str], "")


    @property
    def model_versions_trained(self) -> List[str]:
        """Model versions trained."""
        return self._attributes["model_versions_trained"]


    @model_versions_trained.setter
    def model_versions_trained(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ChangeSummary", "model_versions_trained", value, List[str], "")


    @property
    def feature_sets_added(self) -> List[str]:
        """Feature sets added."""
        return self._attributes["feature_sets_added"]


    @feature_sets_added.setter
    def feature_sets_added(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ChangeSummary", "feature_sets_added", value, List[str], "")


    @property
    def feature_sets_modified(self) -> List[str]:
        """Feature sets modified."""
        return self._attributes["feature_sets_modified"]


    @feature_sets_modified.setter
    def feature_sets_modified(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ChangeSummary", "feature_sets_modified", value, List[str], "")


    @property
    def feature_sets_deleted(self) -> List[str]:
        """Feature sets deleted."""
        return self._attributes["feature_sets_deleted"]


    @feature_sets_deleted.setter
    def feature_sets_deleted(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ChangeSummary", "feature_sets_deleted", value, List[str], "")


    @property
    def features_added(self) -> List[str]:
        """Features added."""
        return self._attributes["features_added"]


    @features_added.setter
    def features_added(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ChangeSummary", "features_added", value, List[str], "")


    @property
    def features_deleted(self) -> List[str]:
        """Features deleted."""
        return self._attributes["features_deleted"]


    @features_deleted.setter
    def features_deleted(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ChangeSummary", "features_deleted", value, List[str], "")


    @property
    def predictions_made(self) -> int:
        """Predictions made."""
        return self._attributes["predictions_made"]


    @predictions_made.setter
    def predictions_made(self, value: int) -> None:
        _set_attribute(self._attributes, "ChangeSummary", "predictions_made", value, int, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.ChangeSummary, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.ChangeSummary:
        """Convert object to proto representation."""
        return management_types_pb2.ChangeSummary(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ChangeSummary object " + repr(self.to_dict()) + ">"


class Change:
    """Change."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , state: ChangeState = 0
        , plan: List[PlanStep] = []
        , create_time: datetime = None
        , start_time: datetime = None
        , finish_time: datetime = None
        , created_by: str = ""
        , cancelled_by: str = ""
        , message: str = ""
        , trigger: str = ""
        , resource: str = ""
        , summary: ChangeSummary = None
    , **kwargs) -> Change:
        self._attributes = dict()
        self.name = name
        self.state = state
        self.plan = plan
        self.create_time = create_time
        self.start_time = start_time
        self.finish_time = finish_time
        self.created_by = created_by
        self.cancelled_by = cancelled_by
        self.message = message
        self.trigger = trigger
        self.resource = resource
        self.summary = summary

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "Change", "name", value, str, "")


    @property
    def state(self) -> ChangeState:
        """Overall Push status"""
        return self._attributes["state"]


    @state.setter
    def state(self, value: ChangeState) -> None:
        _set_attribute(self._attributes, "Change", "state", value, ChangeState, "")


    @property
    def plan(self) -> List[PlanStep]:
        """Plan."""
        return self._attributes["plan"]


    @plan.setter
    def plan(self, value: List[PlanStep]) -> None:
        _set_attribute(self._attributes, "Change", "plan", value, List[PlanStep], "")


    @property
    def create_time(self) -> datetime:
        """When the apply plan was created"""
        return self._attributes["create_time"]


    @create_time.setter
    def create_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Change", "create_time", value, datetime, "")


    @property
    def start_time(self) -> datetime:
        """When the execution of the plan started"""
        return self._attributes["start_time"]


    @start_time.setter
    def start_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Change", "start_time", value, datetime, "")


    @property
    def finish_time(self) -> datetime:
        """Execution finish time of the apply plan."""
        return self._attributes["finish_time"]


    @finish_time.setter
    def finish_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Change", "finish_time", value, datetime, "")


    @property
    def created_by(self) -> str:
        """Created by."""
        return self._attributes["created_by"]


    @created_by.setter
    def created_by(self, value: str) -> None:
        _set_attribute(self._attributes, "Change", "created_by", value, str, "")


    @property
    def cancelled_by(self) -> str:
        """Cancelled by."""
        return self._attributes["cancelled_by"]


    @cancelled_by.setter
    def cancelled_by(self, value: str) -> None:
        _set_attribute(self._attributes, "Change", "cancelled_by", value, str, "")


    @property
    def message(self) -> str:
        """Message."""
        return self._attributes["message"]


    @message.setter
    def message(self, value: str) -> None:
        _set_attribute(self._attributes, "Change", "message", value, str, "")


    @property
    def trigger(self) -> str:
        """Trigger."""
        return self._attributes["trigger"]


    @trigger.setter
    def trigger(self, value: str) -> None:
        _set_attribute(self._attributes, "Change", "trigger", value, str, "")


    @property
    def resource(self) -> str:
        """Resource."""
        return self._attributes["resource"]


    @resource.setter
    def resource(self, value: str) -> None:
        _set_attribute(self._attributes, "Change", "resource", value, str, "")


    @property
    def summary(self) -> ChangeSummary:
        """Summary."""
        return self._attributes["summary"]


    @summary.setter
    def summary(self, value: ChangeSummary) -> None:
        _set_attribute(self._attributes, "Change", "summary", value, ChangeSummary, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.Change, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.Change:
        """Convert object to proto representation."""
        return management_types_pb2.Change(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<Change object " + repr(self.to_dict()) + ">"


class PlanStep:
    """Execution Plan Step"""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , id: int = 0
        , name: str = ""
        , type: PlanStepType = 0
        , operation: PlanStepOperation = 0
        , state: PlanStepState = 0
        , resource_name: str = ""
        , object_name: str = ""
        , dependencies: List[int] = []
        , error_messages: List[str] = []
        , start_time: datetime = None
        , finish_time: datetime = None
        , schema_text: str = ""
        , previous_schema_text: str = ""
        , create_feature_set: PlanStepCreateFeatureSet = None
        , create_model: PlanStepCreateModel = None
        , update_feature_set: PlanStepUpdateFeatureSet = None
        , update_model: PlanStepUpdateModel = None
        , profile_feature_set: PlanStepProfileFeatureSet = None
        , profile_model: PlanStepProfileModel = None
        , train: PlanStepTrain = None
        , promote: PlanStepPromote = None
        , predict: PlanStepPredict = None
        , delete_feature_set: PlanStepDeleteFeatureSet = None
        , delete_model: PlanStepDeleteModel = None
    , **kwargs) -> PlanStep:
        self._attributes = dict()
        self.id = id
        self.name = name
        self.type = type
        self.operation = operation
        self.state = state
        self.resource_name = resource_name
        self.object_name = object_name
        self.dependencies = dependencies
        self.error_messages = error_messages
        self.start_time = start_time
        self.finish_time = finish_time
        self.schema_text = schema_text
        self.previous_schema_text = previous_schema_text
        self.create_feature_set = create_feature_set
        self.create_model = create_model
        self.update_feature_set = update_feature_set
        self.update_model = update_model
        self.profile_feature_set = profile_feature_set
        self.profile_model = profile_model
        self.train = train
        self.promote = promote
        self.predict = predict
        self.delete_feature_set = delete_feature_set
        self.delete_model = delete_model

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def id(self) -> int:
        """Id."""
        return self._attributes["id"]


    @id.setter
    def id(self, value: int) -> None:
        _set_attribute(self._attributes, "PlanStep", "id", value, int, "")


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "PlanStep", "name", value, str, "")


    @property
    def type(self) -> PlanStepType:
        """Type."""
        return self._attributes["type"]


    @type.setter
    def type(self, value: PlanStepType) -> None:
        _set_attribute(self._attributes, "PlanStep", "type", value, PlanStepType, "")


    @property
    def operation(self) -> PlanStepOperation:
        """Operation."""
        return self._attributes["operation"]


    @operation.setter
    def operation(self, value: PlanStepOperation) -> None:
        _set_attribute(self._attributes, "PlanStep", "operation", value, PlanStepOperation, "")


    @property
    def state(self) -> PlanStepState:
        """State."""
        return self._attributes["state"]


    @state.setter
    def state(self, value: PlanStepState) -> None:
        _set_attribute(self._attributes, "PlanStep", "state", value, PlanStepState, "")


    @property
    def resource_name(self) -> str:
        """Resource name."""
        return self._attributes["resource_name"]


    @resource_name.setter
    def resource_name(self, value: str) -> None:
        _set_attribute(self._attributes, "PlanStep", "resource_name", value, str, "")


    @property
    def object_name(self) -> str:
        """Object name."""
        return self._attributes["object_name"]


    @object_name.setter
    def object_name(self, value: str) -> None:
        _set_attribute(self._attributes, "PlanStep", "object_name", value, str, "")


    @property
    def dependencies(self) -> List[int]:
        """Dependencies."""
        return self._attributes["dependencies"]


    @dependencies.setter
    def dependencies(self, value: List[int]) -> None:
        _set_attribute(self._attributes, "PlanStep", "dependencies", value, List[int], "")


    @property
    def error_messages(self) -> List[str]:
        """Error messages."""
        return self._attributes["error_messages"]


    @error_messages.setter
    def error_messages(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "PlanStep", "error_messages", value, List[str], "")


    @property
    def start_time(self) -> datetime:
        """When the execution of the plan step started"""
        return self._attributes["start_time"]


    @start_time.setter
    def start_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "PlanStep", "start_time", value, datetime, "")


    @property
    def finish_time(self) -> datetime:
        """Execution finish time of the step."""
        return self._attributes["finish_time"]


    @finish_time.setter
    def finish_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "PlanStep", "finish_time", value, datetime, "")


    @property
    def schema_text(self) -> str:
        """Schema text."""
        return self._attributes["schema_text"]


    @schema_text.setter
    def schema_text(self, value: str) -> None:
        _set_attribute(self._attributes, "PlanStep", "schema_text", value, str, "")


    @property
    def previous_schema_text(self) -> str:
        """Previous schema text."""
        return self._attributes["previous_schema_text"]


    @previous_schema_text.setter
    def previous_schema_text(self, value: str) -> None:
        _set_attribute(self._attributes, "PlanStep", "previous_schema_text", value, str, "")


    @property
    def create_feature_set(self) -> PlanStepCreateFeatureSet:
        """Create feature set."""
        return self._attributes["create_feature_set"]


    @create_feature_set.setter
    def create_feature_set(self, value: PlanStepCreateFeatureSet) -> None:
        _set_attribute(self._attributes, "PlanStep", "create_feature_set", value, PlanStepCreateFeatureSet, "metadata")


    @property
    def create_model(self) -> PlanStepCreateModel:
        """Create model."""
        return self._attributes["create_model"]


    @create_model.setter
    def create_model(self, value: PlanStepCreateModel) -> None:
        _set_attribute(self._attributes, "PlanStep", "create_model", value, PlanStepCreateModel, "metadata")


    @property
    def update_feature_set(self) -> PlanStepUpdateFeatureSet:
        """Update feature set."""
        return self._attributes["update_feature_set"]


    @update_feature_set.setter
    def update_feature_set(self, value: PlanStepUpdateFeatureSet) -> None:
        _set_attribute(self._attributes, "PlanStep", "update_feature_set", value, PlanStepUpdateFeatureSet, "metadata")


    @property
    def update_model(self) -> PlanStepUpdateModel:
        """Update model."""
        return self._attributes["update_model"]


    @update_model.setter
    def update_model(self, value: PlanStepUpdateModel) -> None:
        _set_attribute(self._attributes, "PlanStep", "update_model", value, PlanStepUpdateModel, "metadata")


    @property
    def profile_feature_set(self) -> PlanStepProfileFeatureSet:
        """Profile feature set."""
        return self._attributes["profile_feature_set"]


    @profile_feature_set.setter
    def profile_feature_set(self, value: PlanStepProfileFeatureSet) -> None:
        _set_attribute(self._attributes, "PlanStep", "profile_feature_set", value, PlanStepProfileFeatureSet, "metadata")


    @property
    def profile_model(self) -> PlanStepProfileModel:
        """Profile model."""
        return self._attributes["profile_model"]


    @profile_model.setter
    def profile_model(self, value: PlanStepProfileModel) -> None:
        _set_attribute(self._attributes, "PlanStep", "profile_model", value, PlanStepProfileModel, "metadata")


    @property
    def train(self) -> PlanStepTrain:
        """Train."""
        return self._attributes["train"]


    @train.setter
    def train(self, value: PlanStepTrain) -> None:
        _set_attribute(self._attributes, "PlanStep", "train", value, PlanStepTrain, "metadata")


    @property
    def promote(self) -> PlanStepPromote:
        """Promote."""
        return self._attributes["promote"]


    @promote.setter
    def promote(self, value: PlanStepPromote) -> None:
        _set_attribute(self._attributes, "PlanStep", "promote", value, PlanStepPromote, "metadata")


    @property
    def predict(self) -> PlanStepPredict:
        """Predict."""
        return self._attributes["predict"]


    @predict.setter
    def predict(self, value: PlanStepPredict) -> None:
        _set_attribute(self._attributes, "PlanStep", "predict", value, PlanStepPredict, "metadata")


    @property
    def delete_feature_set(self) -> PlanStepDeleteFeatureSet:
        """Delete feature set."""
        return self._attributes["delete_feature_set"]


    @delete_feature_set.setter
    def delete_feature_set(self, value: PlanStepDeleteFeatureSet) -> None:
        _set_attribute(self._attributes, "PlanStep", "delete_feature_set", value, PlanStepDeleteFeatureSet, "metadata")


    @property
    def delete_model(self) -> PlanStepDeleteModel:
        """Delete model."""
        return self._attributes["delete_model"]


    @delete_model.setter
    def delete_model(self, value: PlanStepDeleteModel) -> None:
        _set_attribute(self._attributes, "PlanStep", "delete_model", value, PlanStepDeleteModel, "metadata")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.PlanStep, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.PlanStep:
        """Convert object to proto representation."""
        return management_types_pb2.PlanStep(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<PlanStep object " + repr(self.to_dict()) + ">"


class PlanStepCreateModel:
    """Plan step create model."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , model: str = ""
        , schema_text: str = ""
        , added_features: List[str] = []
        , created_views: List[str] = []
    , **kwargs) -> PlanStepCreateModel:
        self._attributes = dict()
        self.model = model
        self.schema_text = schema_text
        self.added_features = added_features
        self.created_views = created_views

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def model(self) -> str:
        """Model."""
        return self._attributes["model"]


    @model.setter
    def model(self, value: str) -> None:
        _set_attribute(self._attributes, "PlanStepCreateModel", "model", value, str, "")


    @property
    def schema_text(self) -> str:
        """Schema text."""
        return self._attributes["schema_text"]


    @schema_text.setter
    def schema_text(self, value: str) -> None:
        _set_attribute(self._attributes, "PlanStepCreateModel", "schema_text", value, str, "")


    @property
    def added_features(self) -> List[str]:
        """Added features."""
        return self._attributes["added_features"]


    @added_features.setter
    def added_features(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "PlanStepCreateModel", "added_features", value, List[str], "")


    @property
    def created_views(self) -> List[str]:
        """Created views."""
        return self._attributes["created_views"]


    @created_views.setter
    def created_views(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "PlanStepCreateModel", "created_views", value, List[str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.PlanStep.CreateModel, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.PlanStep.CreateModel:
        """Convert object to proto representation."""
        return management_types_pb2.PlanStep.CreateModel(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<PlanStepCreateModel object " + repr(self.to_dict()) + ">"


class PlanStepCreateFeatureSet:
    """Plan step create feature set."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , feature_set: str = ""
        , schema_text: str = ""
        , added_features: List[str] = []
        , created_views: List[str] = []
    , **kwargs) -> PlanStepCreateFeatureSet:
        self._attributes = dict()
        self.feature_set = feature_set
        self.schema_text = schema_text
        self.added_features = added_features
        self.created_views = created_views

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def feature_set(self) -> str:
        """Feature set."""
        return self._attributes["feature_set"]


    @feature_set.setter
    def feature_set(self, value: str) -> None:
        _set_attribute(self._attributes, "PlanStepCreateFeatureSet", "feature_set", value, str, "")


    @property
    def schema_text(self) -> str:
        """Schema text."""
        return self._attributes["schema_text"]


    @schema_text.setter
    def schema_text(self, value: str) -> None:
        _set_attribute(self._attributes, "PlanStepCreateFeatureSet", "schema_text", value, str, "")


    @property
    def added_features(self) -> List[str]:
        """Added features."""
        return self._attributes["added_features"]


    @added_features.setter
    def added_features(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "PlanStepCreateFeatureSet", "added_features", value, List[str], "")


    @property
    def created_views(self) -> List[str]:
        """Created views."""
        return self._attributes["created_views"]


    @created_views.setter
    def created_views(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "PlanStepCreateFeatureSet", "created_views", value, List[str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.PlanStep.CreateFeatureSet, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.PlanStep.CreateFeatureSet:
        """Convert object to proto representation."""
        return management_types_pb2.PlanStep.CreateFeatureSet(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<PlanStepCreateFeatureSet object " + repr(self.to_dict()) + ">"


class PlanStepUpdateModel:
    """Plan step update model."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , model: str = ""
        , schema_text: str = ""
        , previous_schema_text: str = ""
        , added_features: List[str] = []
        , updated_features: List[str] = []
        , removed_features: List[str] = []
        , created_views: List[str] = []
        , updated_views: List[str] = []
        , deleted_views: List[str] = []
        , updates: List[PlanStepUpdateModelUpdateType] = []
    , **kwargs) -> PlanStepUpdateModel:
        self._attributes = dict()
        self.model = model
        self.schema_text = schema_text
        self.previous_schema_text = previous_schema_text
        self.added_features = added_features
        self.updated_features = updated_features
        self.removed_features = removed_features
        self.created_views = created_views
        self.updated_views = updated_views
        self.deleted_views = deleted_views
        self.updates = updates

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def model(self) -> str:
        """Model."""
        return self._attributes["model"]


    @model.setter
    def model(self, value: str) -> None:
        _set_attribute(self._attributes, "PlanStepUpdateModel", "model", value, str, "")


    @property
    def schema_text(self) -> str:
        """Schema text."""
        return self._attributes["schema_text"]


    @schema_text.setter
    def schema_text(self, value: str) -> None:
        _set_attribute(self._attributes, "PlanStepUpdateModel", "schema_text", value, str, "")


    @property
    def previous_schema_text(self) -> str:
        """Previous schema text."""
        return self._attributes["previous_schema_text"]


    @previous_schema_text.setter
    def previous_schema_text(self, value: str) -> None:
        _set_attribute(self._attributes, "PlanStepUpdateModel", "previous_schema_text", value, str, "")


    @property
    def added_features(self) -> List[str]:
        """Added features."""
        return self._attributes["added_features"]


    @added_features.setter
    def added_features(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "PlanStepUpdateModel", "added_features", value, List[str], "")


    @property
    def updated_features(self) -> List[str]:
        """Updated features."""
        return self._attributes["updated_features"]


    @updated_features.setter
    def updated_features(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "PlanStepUpdateModel", "updated_features", value, List[str], "")


    @property
    def removed_features(self) -> List[str]:
        """Removed features."""
        return self._attributes["removed_features"]


    @removed_features.setter
    def removed_features(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "PlanStepUpdateModel", "removed_features", value, List[str], "")


    @property
    def created_views(self) -> List[str]:
        """Created views."""
        return self._attributes["created_views"]


    @created_views.setter
    def created_views(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "PlanStepUpdateModel", "created_views", value, List[str], "")


    @property
    def updated_views(self) -> List[str]:
        """Updated views."""
        return self._attributes["updated_views"]


    @updated_views.setter
    def updated_views(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "PlanStepUpdateModel", "updated_views", value, List[str], "")


    @property
    def deleted_views(self) -> List[str]:
        """Deleted views."""
        return self._attributes["deleted_views"]


    @deleted_views.setter
    def deleted_views(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "PlanStepUpdateModel", "deleted_views", value, List[str], "")


    @property
    def updates(self) -> List[PlanStepUpdateModelUpdateType]:
        """Updates."""
        return self._attributes["updates"]


    @updates.setter
    def updates(self, value: List[PlanStepUpdateModelUpdateType]) -> None:
        _set_attribute(self._attributes, "PlanStepUpdateModel", "updates", value, List[PlanStepUpdateModelUpdateType], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.PlanStep.UpdateModel, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.PlanStep.UpdateModel:
        """Convert object to proto representation."""
        return management_types_pb2.PlanStep.UpdateModel(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<PlanStepUpdateModel object " + repr(self.to_dict()) + ">"


class PlanStepUpdateFeatureSet:
    """Plan step update feature set."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , feature_set: str = ""
        , schema_text: str = ""
        , previous_schema_text: str = ""
        , added_features: List[str] = []
        , updated_features: List[str] = []
        , removed_features: List[str] = []
        , created_views: List[str] = []
        , updated_views: List[str] = []
        , deleted_views: List[str] = []
        , updates: List[PlanStepUpdateFeatureSetUpdateType] = []
    , **kwargs) -> PlanStepUpdateFeatureSet:
        self._attributes = dict()
        self.feature_set = feature_set
        self.schema_text = schema_text
        self.previous_schema_text = previous_schema_text
        self.added_features = added_features
        self.updated_features = updated_features
        self.removed_features = removed_features
        self.created_views = created_views
        self.updated_views = updated_views
        self.deleted_views = deleted_views
        self.updates = updates

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def feature_set(self) -> str:
        """Feature set."""
        return self._attributes["feature_set"]


    @feature_set.setter
    def feature_set(self, value: str) -> None:
        _set_attribute(self._attributes, "PlanStepUpdateFeatureSet", "feature_set", value, str, "")


    @property
    def schema_text(self) -> str:
        """Schema text."""
        return self._attributes["schema_text"]


    @schema_text.setter
    def schema_text(self, value: str) -> None:
        _set_attribute(self._attributes, "PlanStepUpdateFeatureSet", "schema_text", value, str, "")


    @property
    def previous_schema_text(self) -> str:
        """Previous schema text."""
        return self._attributes["previous_schema_text"]


    @previous_schema_text.setter
    def previous_schema_text(self, value: str) -> None:
        _set_attribute(self._attributes, "PlanStepUpdateFeatureSet", "previous_schema_text", value, str, "")


    @property
    def added_features(self) -> List[str]:
        """Added features."""
        return self._attributes["added_features"]


    @added_features.setter
    def added_features(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "PlanStepUpdateFeatureSet", "added_features", value, List[str], "")


    @property
    def updated_features(self) -> List[str]:
        """Updated features."""
        return self._attributes["updated_features"]


    @updated_features.setter
    def updated_features(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "PlanStepUpdateFeatureSet", "updated_features", value, List[str], "")


    @property
    def removed_features(self) -> List[str]:
        """Removed features."""
        return self._attributes["removed_features"]


    @removed_features.setter
    def removed_features(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "PlanStepUpdateFeatureSet", "removed_features", value, List[str], "")


    @property
    def created_views(self) -> List[str]:
        """Created views."""
        return self._attributes["created_views"]


    @created_views.setter
    def created_views(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "PlanStepUpdateFeatureSet", "created_views", value, List[str], "")


    @property
    def updated_views(self) -> List[str]:
        """Updated views."""
        return self._attributes["updated_views"]


    @updated_views.setter
    def updated_views(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "PlanStepUpdateFeatureSet", "updated_views", value, List[str], "")


    @property
    def deleted_views(self) -> List[str]:
        """Deleted views."""
        return self._attributes["deleted_views"]


    @deleted_views.setter
    def deleted_views(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "PlanStepUpdateFeatureSet", "deleted_views", value, List[str], "")


    @property
    def updates(self) -> List[PlanStepUpdateFeatureSetUpdateType]:
        """Updates."""
        return self._attributes["updates"]


    @updates.setter
    def updates(self, value: List[PlanStepUpdateFeatureSetUpdateType]) -> None:
        _set_attribute(self._attributes, "PlanStepUpdateFeatureSet", "updates", value, List[PlanStepUpdateFeatureSetUpdateType], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.PlanStep.UpdateFeatureSet, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.PlanStep.UpdateFeatureSet:
        """Convert object to proto representation."""
        return management_types_pb2.PlanStep.UpdateFeatureSet(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<PlanStepUpdateFeatureSet object " + repr(self.to_dict()) + ">"


class PlanStepProfileFeatureSet:
    """Plan step profile feature set."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , feature_set: str = ""
        , rows_profiled: int = 0
        , previous_rows_profiled: int = 0
        , data_checks: DataChecks = None
    , **kwargs) -> PlanStepProfileFeatureSet:
        self._attributes = dict()
        self.feature_set = feature_set
        self.rows_profiled = rows_profiled
        self.previous_rows_profiled = previous_rows_profiled
        self.data_checks = data_checks

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def feature_set(self) -> str:
        """Feature set."""
        return self._attributes["feature_set"]


    @feature_set.setter
    def feature_set(self, value: str) -> None:
        _set_attribute(self._attributes, "PlanStepProfileFeatureSet", "feature_set", value, str, "")


    @property
    def rows_profiled(self) -> int:
        """Rows profiled."""
        return self._attributes["rows_profiled"]


    @rows_profiled.setter
    def rows_profiled(self, value: int) -> None:
        _set_attribute(self._attributes, "PlanStepProfileFeatureSet", "rows_profiled", value, int, "")


    @property
    def previous_rows_profiled(self) -> int:
        """Previous rows profiled."""
        return self._attributes["previous_rows_profiled"]


    @previous_rows_profiled.setter
    def previous_rows_profiled(self, value: int) -> None:
        _set_attribute(self._attributes, "PlanStepProfileFeatureSet", "previous_rows_profiled", value, int, "")


    @property
    def data_checks(self) -> DataChecks:
        """Data checks."""
        return self._attributes["data_checks"]


    @data_checks.setter
    def data_checks(self, value: DataChecks) -> None:
        _set_attribute(self._attributes, "PlanStepProfileFeatureSet", "data_checks", value, DataChecks, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.PlanStep.ProfileFeatureSet, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.PlanStep.ProfileFeatureSet:
        """Convert object to proto representation."""
        return management_types_pb2.PlanStep.ProfileFeatureSet(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<PlanStepProfileFeatureSet object " + repr(self.to_dict()) + ">"


class PlanStepProfileModel:
    """Plan step profile model."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , model: str = ""
        , rows_profiled: int = 0
        , previous_rows_profiled: int = 0
        , data_checks: DataChecks = None
    , **kwargs) -> PlanStepProfileModel:
        self._attributes = dict()
        self.model = model
        self.rows_profiled = rows_profiled
        self.previous_rows_profiled = previous_rows_profiled
        self.data_checks = data_checks

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def model(self) -> str:
        """Model."""
        return self._attributes["model"]


    @model.setter
    def model(self, value: str) -> None:
        _set_attribute(self._attributes, "PlanStepProfileModel", "model", value, str, "")


    @property
    def rows_profiled(self) -> int:
        """Rows profiled."""
        return self._attributes["rows_profiled"]


    @rows_profiled.setter
    def rows_profiled(self, value: int) -> None:
        _set_attribute(self._attributes, "PlanStepProfileModel", "rows_profiled", value, int, "")


    @property
    def previous_rows_profiled(self) -> int:
        """Previous rows profiled."""
        return self._attributes["previous_rows_profiled"]


    @previous_rows_profiled.setter
    def previous_rows_profiled(self, value: int) -> None:
        _set_attribute(self._attributes, "PlanStepProfileModel", "previous_rows_profiled", value, int, "")


    @property
    def data_checks(self) -> DataChecks:
        """Data checks."""
        return self._attributes["data_checks"]


    @data_checks.setter
    def data_checks(self, value: DataChecks) -> None:
        _set_attribute(self._attributes, "PlanStepProfileModel", "data_checks", value, DataChecks, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.PlanStep.ProfileModel, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.PlanStep.ProfileModel:
        """Convert object to proto representation."""
        return management_types_pb2.PlanStep.ProfileModel(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<PlanStepProfileModel object " + repr(self.to_dict()) + ">"


class PlanStepPredict:
    """Plan step predict."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , batch_prediction: str = ""
        , previous_batch_prediction: str = ""
        , prediction_count: int = 0
        , previous_prediction_count: int = 0
    , **kwargs) -> PlanStepPredict:
        self._attributes = dict()
        self.batch_prediction = batch_prediction
        self.previous_batch_prediction = previous_batch_prediction
        self.prediction_count = prediction_count
        self.previous_prediction_count = previous_prediction_count

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def batch_prediction(self) -> str:
        """Batch prediction."""
        return self._attributes["batch_prediction"]


    @batch_prediction.setter
    def batch_prediction(self, value: str) -> None:
        _set_attribute(self._attributes, "PlanStepPredict", "batch_prediction", value, str, "")


    @property
    def previous_batch_prediction(self) -> str:
        """Previous batch prediction."""
        return self._attributes["previous_batch_prediction"]


    @previous_batch_prediction.setter
    def previous_batch_prediction(self, value: str) -> None:
        _set_attribute(self._attributes, "PlanStepPredict", "previous_batch_prediction", value, str, "")


    @property
    def prediction_count(self) -> int:
        """Prediction count."""
        return self._attributes["prediction_count"]


    @prediction_count.setter
    def prediction_count(self, value: int) -> None:
        _set_attribute(self._attributes, "PlanStepPredict", "prediction_count", value, int, "")


    @property
    def previous_prediction_count(self) -> int:
        """Previous prediction count."""
        return self._attributes["previous_prediction_count"]


    @previous_prediction_count.setter
    def previous_prediction_count(self, value: int) -> None:
        _set_attribute(self._attributes, "PlanStepPredict", "previous_prediction_count", value, int, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.PlanStep.Predict, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.PlanStep.Predict:
        """Convert object to proto representation."""
        return management_types_pb2.PlanStep.Predict(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<PlanStepPredict object " + repr(self.to_dict()) + ">"


class PlanStepTrain:
    """Plan step train."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , model_version: str = ""
        , base_model_version: str = ""
        , base_model_version_type: PlanStepTrainBaseModelVersionType = 0
        , reason: PlanStepTrainReason = 0
        , latest_model_version: str = ""
        , promoted_model_version: str = ""
        , production_model_version: str = ""
    , **kwargs) -> PlanStepTrain:
        self._attributes = dict()
        self.model_version = model_version
        self.base_model_version = base_model_version
        self.base_model_version_type = base_model_version_type
        self.reason = reason
        self.latest_model_version = latest_model_version
        self.promoted_model_version = promoted_model_version
        self.production_model_version = production_model_version

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def model_version(self) -> str:
        """Model version."""
        return self._attributes["model_version"]


    @model_version.setter
    def model_version(self, value: str) -> None:
        _set_attribute(self._attributes, "PlanStepTrain", "model_version", value, str, "")


    @property
    def base_model_version(self) -> str:
        """Base model version."""
        return self._attributes["base_model_version"]


    @base_model_version.setter
    def base_model_version(self, value: str) -> None:
        _set_attribute(self._attributes, "PlanStepTrain", "base_model_version", value, str, "")


    @property
    def base_model_version_type(self) -> PlanStepTrainBaseModelVersionType:
        """Base model version type."""
        return self._attributes["base_model_version_type"]


    @base_model_version_type.setter
    def base_model_version_type(self, value: PlanStepTrainBaseModelVersionType) -> None:
        _set_attribute(self._attributes, "PlanStepTrain", "base_model_version_type", value, PlanStepTrainBaseModelVersionType, "")


    @property
    def reason(self) -> PlanStepTrainReason:
        """Reason."""
        return self._attributes["reason"]


    @reason.setter
    def reason(self, value: PlanStepTrainReason) -> None:
        _set_attribute(self._attributes, "PlanStepTrain", "reason", value, PlanStepTrainReason, "")


    @property
    def latest_model_version(self) -> str:
        """Latest model version."""
        return self._attributes["latest_model_version"]


    @latest_model_version.setter
    def latest_model_version(self, value: str) -> None:
        _set_attribute(self._attributes, "PlanStepTrain", "latest_model_version", value, str, "")


    @property
    def promoted_model_version(self) -> str:
        """Promoted model version."""
        return self._attributes["promoted_model_version"]


    @promoted_model_version.setter
    def promoted_model_version(self, value: str) -> None:
        _set_attribute(self._attributes, "PlanStepTrain", "promoted_model_version", value, str, "")


    @property
    def production_model_version(self) -> str:
        """Production model version."""
        return self._attributes["production_model_version"]


    @production_model_version.setter
    def production_model_version(self, value: str) -> None:
        _set_attribute(self._attributes, "PlanStepTrain", "production_model_version", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.PlanStep.Train, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.PlanStep.Train:
        """Convert object to proto representation."""
        return management_types_pb2.PlanStep.Train(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<PlanStepTrain object " + repr(self.to_dict()) + ">"


class PlanStepPromote:
    """Plan step promote."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , promotion: str = ""
    , **kwargs) -> PlanStepPromote:
        self._attributes = dict()
        self.promotion = promotion

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def promotion(self) -> str:
        """Promotion."""
        return self._attributes["promotion"]


    @promotion.setter
    def promotion(self, value: str) -> None:
        _set_attribute(self._attributes, "PlanStepPromote", "promotion", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.PlanStep.Promote, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.PlanStep.Promote:
        """Convert object to proto representation."""
        return management_types_pb2.PlanStep.Promote(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<PlanStepPromote object " + repr(self.to_dict()) + ">"


class PlanStepDeleteModel:
    """Plan step delete model."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , deleted_views: List[str] = []
        , deleted_features: List[str] = []
    , **kwargs) -> PlanStepDeleteModel:
        self._attributes = dict()
        self.deleted_views = deleted_views
        self.deleted_features = deleted_features

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def deleted_views(self) -> List[str]:
        """Deleted views."""
        return self._attributes["deleted_views"]


    @deleted_views.setter
    def deleted_views(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "PlanStepDeleteModel", "deleted_views", value, List[str], "")


    @property
    def deleted_features(self) -> List[str]:
        """Deleted features."""
        return self._attributes["deleted_features"]


    @deleted_features.setter
    def deleted_features(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "PlanStepDeleteModel", "deleted_features", value, List[str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.PlanStep.DeleteModel, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.PlanStep.DeleteModel:
        """Convert object to proto representation."""
        return management_types_pb2.PlanStep.DeleteModel(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<PlanStepDeleteModel object " + repr(self.to_dict()) + ">"


class PlanStepDeleteFeatureSet:
    """Plan step delete feature set."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , deleted_views: List[str] = []
        , deleted_features: List[str] = []
    , **kwargs) -> PlanStepDeleteFeatureSet:
        self._attributes = dict()
        self.deleted_views = deleted_views
        self.deleted_features = deleted_features

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def deleted_views(self) -> List[str]:
        """Deleted views."""
        return self._attributes["deleted_views"]


    @deleted_views.setter
    def deleted_views(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "PlanStepDeleteFeatureSet", "deleted_views", value, List[str], "")


    @property
    def deleted_features(self) -> List[str]:
        """Deleted features."""
        return self._attributes["deleted_features"]


    @deleted_features.setter
    def deleted_features(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "PlanStepDeleteFeatureSet", "deleted_features", value, List[str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.PlanStep.DeleteFeatureSet, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.PlanStep.DeleteFeatureSet:
        """Convert object to proto representation."""
        return management_types_pb2.PlanStep.DeleteFeatureSet(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<PlanStepDeleteFeatureSet object " + repr(self.to_dict()) + ">"


class BatchPrediction:
    """Batch prediction."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , state: BatchPredictionState = 0
        , model_version: str = ""
        , source_type: BatchPredictionStoreType = 0
        , source: str = ""
        , dest_type: BatchPredictionStoreType = 0
        , incremental: bool = False
        , csv_file_path: str = ""
        , create_time: datetime = None
        , start_time: datetime = None
        , end_time: datetime = None
        , prediction_count: int = 0
        , error_message: str = ""
        , stack_trace: str = ""
        , log_file_paths: Dict[str, str] = None
        , prediction_model: str = ""
        , table: str = ""
        , credits_used: int = 0
    , **kwargs) -> BatchPrediction:
        self._attributes = dict()
        self.name = name
        self.state = state
        self.model_version = model_version
        self.source_type = source_type
        self.source = source
        self.dest_type = dest_type
        self.incremental = incremental
        self.csv_file_path = csv_file_path
        self.create_time = create_time
        self.start_time = start_time
        self.end_time = end_time
        self.prediction_count = prediction_count
        self.error_message = error_message
        self.stack_trace = stack_trace
        self.log_file_paths = log_file_paths
        self.prediction_model = prediction_model
        self.table = table
        self.credits_used = credits_used

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "BatchPrediction", "name", value, str, "")


    @property
    def state(self) -> BatchPredictionState:
        """State."""
        return self._attributes["state"]


    @state.setter
    def state(self, value: BatchPredictionState) -> None:
        _set_attribute(self._attributes, "BatchPrediction", "state", value, BatchPredictionState, "")


    @property
    def model_version(self) -> str:
        """Model version."""
        return self._attributes["model_version"]


    @model_version.setter
    def model_version(self, value: str) -> None:
        _set_attribute(self._attributes, "BatchPrediction", "model_version", value, str, "")


    @property
    def source_type(self) -> BatchPredictionStoreType:
        """Source type."""
        return self._attributes["source_type"]


    @source_type.setter
    def source_type(self, value: BatchPredictionStoreType) -> None:
        _set_attribute(self._attributes, "BatchPrediction", "source_type", value, BatchPredictionStoreType, "")


    @property
    def source(self) -> str:
        """Source."""
        return self._attributes["source"]


    @source.setter
    def source(self, value: str) -> None:
        _set_attribute(self._attributes, "BatchPrediction", "source", value, str, "")


    @property
    def dest_type(self) -> BatchPredictionStoreType:
        """Dest type."""
        return self._attributes["dest_type"]


    @dest_type.setter
    def dest_type(self, value: BatchPredictionStoreType) -> None:
        _set_attribute(self._attributes, "BatchPrediction", "dest_type", value, BatchPredictionStoreType, "")


    @property
    def incremental(self) -> bool:
        """Incremental."""
        return self._attributes["incremental"]


    @incremental.setter
    def incremental(self, value: bool) -> None:
        _set_attribute(self._attributes, "BatchPrediction", "incremental", value, bool, "")


    @property
    def csv_file_path(self) -> str:
        """Csv file path."""
        return self._attributes["csv_file_path"]


    @csv_file_path.setter
    def csv_file_path(self, value: str) -> None:
        _set_attribute(self._attributes, "BatchPrediction", "csv_file_path", value, str, "")


    @property
    def create_time(self) -> datetime:
        """Create time."""
        return self._attributes["create_time"]


    @create_time.setter
    def create_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "BatchPrediction", "create_time", value, datetime, "")


    @property
    def start_time(self) -> datetime:
        """Start time."""
        return self._attributes["start_time"]


    @start_time.setter
    def start_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "BatchPrediction", "start_time", value, datetime, "")


    @property
    def end_time(self) -> datetime:
        """End time."""
        return self._attributes["end_time"]


    @end_time.setter
    def end_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "BatchPrediction", "end_time", value, datetime, "")


    @property
    def prediction_count(self) -> int:
        """Prediction count."""
        return self._attributes["prediction_count"]


    @prediction_count.setter
    def prediction_count(self, value: int) -> None:
        _set_attribute(self._attributes, "BatchPrediction", "prediction_count", value, int, "")


    @property
    def error_message(self) -> str:
        """Error message."""
        return self._attributes["error_message"]


    @error_message.setter
    def error_message(self, value: str) -> None:
        _set_attribute(self._attributes, "BatchPrediction", "error_message", value, str, "")


    @property
    def stack_trace(self) -> str:
        """Stack trace."""
        return self._attributes["stack_trace"]


    @stack_trace.setter
    def stack_trace(self, value: str) -> None:
        _set_attribute(self._attributes, "BatchPrediction", "stack_trace", value, str, "")


    @property
    def log_file_paths(self) -> Dict[str, str]:
        """Log file paths."""
        return self._attributes["log_file_paths"]


    @log_file_paths.setter
    def log_file_paths(self, value: Dict[str, str]) -> None:
        _set_attribute(self._attributes, "BatchPrediction", "log_file_paths", value, Dict[str, str], "")


    @property
    def prediction_model(self) -> str:
        """Prediction model."""
        return self._attributes["prediction_model"]


    @prediction_model.setter
    def prediction_model(self, value: str) -> None:
        _set_attribute(self._attributes, "BatchPrediction", "prediction_model", value, str, "")


    @property
    def table(self) -> str:
        """Table."""
        return self._attributes["table"]


    @table.setter
    def table(self, value: str) -> None:
        _set_attribute(self._attributes, "BatchPrediction", "table", value, str, "")


    @property
    def credits_used(self) -> int:
        """Credits used."""
        return self._attributes["credits_used"]


    @credits_used.setter
    def credits_used(self, value: int) -> None:
        _set_attribute(self._attributes, "BatchPrediction", "credits_used", value, int, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.BatchPrediction, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.BatchPrediction:
        """Convert object to proto representation."""
        return management_types_pb2.BatchPrediction(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchPrediction object " + repr(self.to_dict()) + ">"


class SignedURL:
    """Signed u r l."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , signed_url: str = ""
    , **kwargs) -> SignedURL:
        self._attributes = dict()
        self.signed_url = signed_url

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def signed_url(self) -> str:
        """Signed url."""
        return self._attributes["signed_url"]


    @signed_url.setter
    def signed_url(self, value: str) -> None:
        _set_attribute(self._attributes, "SignedURL", "signed_url", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.SignedURL, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.SignedURL:
        """Convert object to proto representation."""
        return management_types_pb2.SignedURL(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<SignedURL object " + repr(self.to_dict()) + ">"


class Entity:
    """Entity."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , models: List[str] = []
        , feature_sets: List[str] = []
    , **kwargs) -> Entity:
        self._attributes = dict()
        self.name = name
        self.models = models
        self.feature_sets = feature_sets

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "Entity", "name", value, str, "")


    @property
    def models(self) -> List[str]:
        """Models."""
        return self._attributes["models"]


    @models.setter
    def models(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "Entity", "models", value, List[str], "")


    @property
    def feature_sets(self) -> List[str]:
        """Feature sets."""
        return self._attributes["feature_sets"]


    @feature_sets.setter
    def feature_sets(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "Entity", "feature_sets", value, List[str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.Entity, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.Entity:
        """Convert object to proto representation."""
        return management_types_pb2.Entity(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<Entity object " + repr(self.to_dict()) + ">"


class DatasetStats:
    """Dataset stats."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , dataset_stats: List[DatasetStatsEntry] = []
        , profile_time: datetime = None
        , resource_name: str = ""
    , **kwargs) -> DatasetStats:
        self._attributes = dict()
        self.name = name
        self.dataset_stats = dataset_stats
        self.profile_time = profile_time
        self.resource_name = resource_name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """this could have a single value if you are profiling a single data set
 if you have a bundle, say training/test/validation then you'd have 
 a entry for each in this list"""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "DatasetStats", "name", value, str, "")


    @property
    def dataset_stats(self) -> List[DatasetStatsEntry]:
        """Dataset stats."""
        return self._attributes["dataset_stats"]


    @dataset_stats.setter
    def dataset_stats(self, value: List[DatasetStatsEntry]) -> None:
        _set_attribute(self._attributes, "DatasetStats", "dataset_stats", value, List[DatasetStatsEntry], "")


    @property
    def profile_time(self) -> datetime:
        """Profile time."""
        return self._attributes["profile_time"]


    @profile_time.setter
    def profile_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "DatasetStats", "profile_time", value, datetime, "")


    @property
    def resource_name(self) -> str:
        """Resource name."""
        return self._attributes["resource_name"]


    @resource_name.setter
    def resource_name(self, value: str) -> None:
        _set_attribute(self._attributes, "DatasetStats", "resource_name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.DatasetStats, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.DatasetStats:
        """Convert object to proto representation."""
        return management_types_pb2.DatasetStats(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<DatasetStats object " + repr(self.to_dict()) + ">"


class DatasetStatsEntry:
    """Dataset stats entry."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , entry_name: str = ""
        , num_examples: int = 0
        , correlation_matrix: CorrelationMatrix = None
        , string_stats: List[StringStats] = []
        , numeric_stats: List[NumericStats] = []
        , timestamp_stats: List[TimestampStats] = []
        , categorical_stats: List[CategoricalStats] = []
        , duplicate_rows: int = 0
        , duplicate_indexes: int = 0
        , dataset_ranges: List[DatasetRange] = []
    , **kwargs) -> DatasetStatsEntry:
        self._attributes = dict()
        self.entry_name = entry_name
        self.num_examples = num_examples
        self.correlation_matrix = correlation_matrix
        self.string_stats = string_stats
        self.numeric_stats = numeric_stats
        self.timestamp_stats = timestamp_stats
        self.categorical_stats = categorical_stats
        self.duplicate_rows = duplicate_rows
        self.duplicate_indexes = duplicate_indexes
        self.dataset_ranges = dataset_ranges

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def entry_name(self) -> str:
        """- Correlation Matrix
 - Feature Distributions
 - Quantiles
 - Duplicate stats
 - Non-unique indexes
 - Skewness - TODO"""
        return self._attributes["entry_name"]


    @entry_name.setter
    def entry_name(self, value: str) -> None:
        _set_attribute(self._attributes, "DatasetStatsEntry", "entry_name", value, str, "")


    @property
    def num_examples(self) -> int:
        """Num examples."""
        return self._attributes["num_examples"]


    @num_examples.setter
    def num_examples(self, value: int) -> None:
        _set_attribute(self._attributes, "DatasetStatsEntry", "num_examples", value, int, "")


    @property
    def correlation_matrix(self) -> CorrelationMatrix:
        """Correlation matrix."""
        return self._attributes["correlation_matrix"]


    @correlation_matrix.setter
    def correlation_matrix(self, value: CorrelationMatrix) -> None:
        _set_attribute(self._attributes, "DatasetStatsEntry", "correlation_matrix", value, CorrelationMatrix, "")


    @property
    def string_stats(self) -> List[StringStats]:
        """String stats."""
        return self._attributes["string_stats"]


    @string_stats.setter
    def string_stats(self, value: List[StringStats]) -> None:
        _set_attribute(self._attributes, "DatasetStatsEntry", "string_stats", value, List[StringStats], "")


    @property
    def numeric_stats(self) -> List[NumericStats]:
        """Numeric stats."""
        return self._attributes["numeric_stats"]


    @numeric_stats.setter
    def numeric_stats(self, value: List[NumericStats]) -> None:
        _set_attribute(self._attributes, "DatasetStatsEntry", "numeric_stats", value, List[NumericStats], "")


    @property
    def timestamp_stats(self) -> List[TimestampStats]:
        """Timestamp stats."""
        return self._attributes["timestamp_stats"]


    @timestamp_stats.setter
    def timestamp_stats(self, value: List[TimestampStats]) -> None:
        _set_attribute(self._attributes, "DatasetStatsEntry", "timestamp_stats", value, List[TimestampStats], "")


    @property
    def categorical_stats(self) -> List[CategoricalStats]:
        """Categorical stats."""
        return self._attributes["categorical_stats"]


    @categorical_stats.setter
    def categorical_stats(self, value: List[CategoricalStats]) -> None:
        _set_attribute(self._attributes, "DatasetStatsEntry", "categorical_stats", value, List[CategoricalStats], "")


    @property
    def duplicate_rows(self) -> int:
        """Duplicate rows."""
        return self._attributes["duplicate_rows"]


    @duplicate_rows.setter
    def duplicate_rows(self, value: int) -> None:
        _set_attribute(self._attributes, "DatasetStatsEntry", "duplicate_rows", value, int, "")


    @property
    def duplicate_indexes(self) -> int:
        """Duplicate indexes."""
        return self._attributes["duplicate_indexes"]


    @duplicate_indexes.setter
    def duplicate_indexes(self, value: int) -> None:
        _set_attribute(self._attributes, "DatasetStatsEntry", "duplicate_indexes", value, int, "")


    @property
    def dataset_ranges(self) -> List[DatasetRange]:
        """Dataset ranges."""
        return self._attributes["dataset_ranges"]


    @dataset_ranges.setter
    def dataset_ranges(self, value: List[DatasetRange]) -> None:
        _set_attribute(self._attributes, "DatasetStatsEntry", "dataset_ranges", value, List[DatasetRange], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.DatasetStatsEntry, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.DatasetStatsEntry:
        """Convert object to proto representation."""
        return management_types_pb2.DatasetStatsEntry(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<DatasetStatsEntry object " + repr(self.to_dict()) + ">"


class DatasetRange:
    """Dataset range."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , start_time: datetime = None
        , end_time: datetime = None
    , **kwargs) -> DatasetRange:
        self._attributes = dict()
        self.name = name
        self.start_time = start_time
        self.end_time = end_time

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "DatasetRange", "name", value, str, "")


    @property
    def start_time(self) -> datetime:
        """Start time."""
        return self._attributes["start_time"]


    @start_time.setter
    def start_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "DatasetRange", "start_time", value, datetime, "")


    @property
    def end_time(self) -> datetime:
        """End time."""
        return self._attributes["end_time"]


    @end_time.setter
    def end_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "DatasetRange", "end_time", value, datetime, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.DatasetRange, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.DatasetRange:
        """Convert object to proto representation."""
        return management_types_pb2.DatasetRange(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<DatasetRange object " + repr(self.to_dict()) + ">"


class CorrelationMatrix:
    """Correlation matrix."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , display_names: List[str] = []
        , rows: List[CorrelationMatrixRow] = []
    , **kwargs) -> CorrelationMatrix:
        self._attributes = dict()
        self.display_names = display_names
        self.rows = rows

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def display_names(self) -> List[str]:
        """Display names."""
        return self._attributes["display_names"]


    @display_names.setter
    def display_names(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "CorrelationMatrix", "display_names", value, List[str], "")


    @property
    def rows(self) -> List[CorrelationMatrixRow]:
        """Rows."""
        return self._attributes["rows"]


    @rows.setter
    def rows(self, value: List[CorrelationMatrixRow]) -> None:
        _set_attribute(self._attributes, "CorrelationMatrix", "rows", value, List[CorrelationMatrixRow], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.CorrelationMatrix, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.CorrelationMatrix:
        """Convert object to proto representation."""
        return management_types_pb2.CorrelationMatrix(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<CorrelationMatrix object " + repr(self.to_dict()) + ">"


class CorrelationMatrixRow:
    """Correlation matrix row."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , correlations: List[float] = []
    , **kwargs) -> CorrelationMatrixRow:
        self._attributes = dict()
        self.correlations = correlations

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def correlations(self) -> List[float]:
        """Correlations."""
        return self._attributes["correlations"]


    @correlations.setter
    def correlations(self, value: List[float]) -> None:
        _set_attribute(self._attributes, "CorrelationMatrixRow", "correlations", value, List[float], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.CorrelationMatrix.Row, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.CorrelationMatrix.Row:
        """Convert object to proto representation."""
        return management_types_pb2.CorrelationMatrix.Row(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<CorrelationMatrixRow object " + repr(self.to_dict()) + ">"


class Histogram:
    """Histogram."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , num_nan: int = 0
        , num_undefined: int = 0
        , buckets: List[HistogramBucket] = []
    , **kwargs) -> Histogram:
        self._attributes = dict()
        self.num_nan = num_nan
        self.num_undefined = num_undefined
        self.buckets = buckets

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def num_nan(self) -> int:
        """Num nan."""
        return self._attributes["num_nan"]


    @num_nan.setter
    def num_nan(self, value: int) -> None:
        _set_attribute(self._attributes, "Histogram", "num_nan", value, int, "")


    @property
    def num_undefined(self) -> int:
        """Num undefined."""
        return self._attributes["num_undefined"]


    @num_undefined.setter
    def num_undefined(self, value: int) -> None:
        _set_attribute(self._attributes, "Histogram", "num_undefined", value, int, "")


    @property
    def buckets(self) -> List[HistogramBucket]:
        """Buckets."""
        return self._attributes["buckets"]


    @buckets.setter
    def buckets(self, value: List[HistogramBucket]) -> None:
        _set_attribute(self._attributes, "Histogram", "buckets", value, List[HistogramBucket], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.Histogram, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.Histogram:
        """Convert object to proto representation."""
        return management_types_pb2.Histogram(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<Histogram object " + repr(self.to_dict()) + ">"


class HistogramBucket:
    """Histogram bucket."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , low_value: float = 0.0
        , high_value: float = 0.0
        , sample_count: int = 0
    , **kwargs) -> HistogramBucket:
        self._attributes = dict()
        self.low_value = low_value
        self.high_value = high_value
        self.sample_count = sample_count

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def low_value(self) -> float:
        """Low value."""
        return self._attributes["low_value"]


    @low_value.setter
    def low_value(self, value: float) -> None:
        _set_attribute(self._attributes, "HistogramBucket", "low_value", value, float, "")


    @property
    def high_value(self) -> float:
        """High value."""
        return self._attributes["high_value"]


    @high_value.setter
    def high_value(self, value: float) -> None:
        _set_attribute(self._attributes, "HistogramBucket", "high_value", value, float, "")


    @property
    def sample_count(self) -> int:
        """Sample count."""
        return self._attributes["sample_count"]


    @sample_count.setter
    def sample_count(self, value: int) -> None:
        _set_attribute(self._attributes, "HistogramBucket", "sample_count", value, int, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.Histogram.Bucket, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.Histogram.Bucket:
        """Convert object to proto representation."""
        return management_types_pb2.Histogram.Bucket(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<HistogramBucket object " + repr(self.to_dict()) + ">"


class TimestampHistogram:
    """Timestamp histogram."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , num_nan: int = 0
        , num_undefined: int = 0
        , buckets: List[TimestampHistogramBucket] = []
    , **kwargs) -> TimestampHistogram:
        self._attributes = dict()
        self.num_nan = num_nan
        self.num_undefined = num_undefined
        self.buckets = buckets

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def num_nan(self) -> int:
        """Num nan."""
        return self._attributes["num_nan"]


    @num_nan.setter
    def num_nan(self, value: int) -> None:
        _set_attribute(self._attributes, "TimestampHistogram", "num_nan", value, int, "")


    @property
    def num_undefined(self) -> int:
        """Num undefined."""
        return self._attributes["num_undefined"]


    @num_undefined.setter
    def num_undefined(self, value: int) -> None:
        _set_attribute(self._attributes, "TimestampHistogram", "num_undefined", value, int, "")


    @property
    def buckets(self) -> List[TimestampHistogramBucket]:
        """Buckets."""
        return self._attributes["buckets"]


    @buckets.setter
    def buckets(self, value: List[TimestampHistogramBucket]) -> None:
        _set_attribute(self._attributes, "TimestampHistogram", "buckets", value, List[TimestampHistogramBucket], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.TimestampHistogram, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.TimestampHistogram:
        """Convert object to proto representation."""
        return management_types_pb2.TimestampHistogram(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<TimestampHistogram object " + repr(self.to_dict()) + ">"


class TimestampHistogramBucket:
    """Timestamp histogram bucket."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , low_value: datetime = None
        , high_value: datetime = None
        , sample_count: int = 0
    , **kwargs) -> TimestampHistogramBucket:
        self._attributes = dict()
        self.low_value = low_value
        self.high_value = high_value
        self.sample_count = sample_count

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def low_value(self) -> datetime:
        """Low value."""
        return self._attributes["low_value"]


    @low_value.setter
    def low_value(self, value: datetime) -> None:
        _set_attribute(self._attributes, "TimestampHistogramBucket", "low_value", value, datetime, "")


    @property
    def high_value(self) -> datetime:
        """High value."""
        return self._attributes["high_value"]


    @high_value.setter
    def high_value(self, value: datetime) -> None:
        _set_attribute(self._attributes, "TimestampHistogramBucket", "high_value", value, datetime, "")


    @property
    def sample_count(self) -> int:
        """Sample count."""
        return self._attributes["sample_count"]


    @sample_count.setter
    def sample_count(self, value: int) -> None:
        _set_attribute(self._attributes, "TimestampHistogramBucket", "sample_count", value, int, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.TimestampHistogram.Bucket, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.TimestampHistogram.Bucket:
        """Convert object to proto representation."""
        return management_types_pb2.TimestampHistogram.Bucket(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<TimestampHistogramBucket object " + repr(self.to_dict()) + ">"


class CategoricalDistribution:
    """store first 20 or so"""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , categories: List[CategoricalDistributionCategory] = []
    , **kwargs) -> CategoricalDistribution:
        self._attributes = dict()
        self.categories = categories

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def categories(self) -> List[CategoricalDistributionCategory]:
        """Categories."""
        return self._attributes["categories"]


    @categories.setter
    def categories(self, value: List[CategoricalDistributionCategory]) -> None:
        _set_attribute(self._attributes, "CategoricalDistribution", "categories", value, List[CategoricalDistributionCategory], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.CategoricalDistribution, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.CategoricalDistribution:
        """Convert object to proto representation."""
        return management_types_pb2.CategoricalDistribution(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<CategoricalDistribution object " + repr(self.to_dict()) + ">"


class CategoricalDistributionCategory:
    """Categorical distribution category."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , label: str = ""
        , sample_count: int = 0
    , **kwargs) -> CategoricalDistributionCategory:
        self._attributes = dict()
        self.label = label
        self.sample_count = sample_count

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def label(self) -> str:
        """Label."""
        return self._attributes["label"]


    @label.setter
    def label(self, value: str) -> None:
        _set_attribute(self._attributes, "CategoricalDistributionCategory", "label", value, str, "")


    @property
    def sample_count(self) -> int:
        """Sample count."""
        return self._attributes["sample_count"]


    @sample_count.setter
    def sample_count(self, value: int) -> None:
        _set_attribute(self._attributes, "CategoricalDistributionCategory", "sample_count", value, int, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.CategoricalDistribution.Category, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.CategoricalDistribution.Category:
        """Convert object to proto representation."""
        return management_types_pb2.CategoricalDistribution.Category(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<CategoricalDistributionCategory object " + repr(self.to_dict()) + ">"


class StringStats:
    """String stats."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , column_name: str = ""
        , distinct_values: int = 0
        , null_count: int = 0
        , min_length: int = 0
        , max_length: int = 0
    , **kwargs) -> StringStats:
        self._attributes = dict()
        self.column_name = column_name
        self.distinct_values = distinct_values
        self.null_count = null_count
        self.min_length = min_length
        self.max_length = max_length

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def column_name(self) -> str:
        """Column name."""
        return self._attributes["column_name"]


    @column_name.setter
    def column_name(self, value: str) -> None:
        _set_attribute(self._attributes, "StringStats", "column_name", value, str, "")


    @property
    def distinct_values(self) -> int:
        """Distinct values."""
        return self._attributes["distinct_values"]


    @distinct_values.setter
    def distinct_values(self, value: int) -> None:
        _set_attribute(self._attributes, "StringStats", "distinct_values", value, int, "")


    @property
    def null_count(self) -> int:
        """Null count."""
        return self._attributes["null_count"]


    @null_count.setter
    def null_count(self, value: int) -> None:
        _set_attribute(self._attributes, "StringStats", "null_count", value, int, "")


    @property
    def min_length(self) -> int:
        """Min length."""
        return self._attributes["min_length"]


    @min_length.setter
    def min_length(self, value: int) -> None:
        _set_attribute(self._attributes, "StringStats", "min_length", value, int, "")


    @property
    def max_length(self) -> int:
        """Max length."""
        return self._attributes["max_length"]


    @max_length.setter
    def max_length(self, value: int) -> None:
        _set_attribute(self._attributes, "StringStats", "max_length", value, int, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.StringStats, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.StringStats:
        """Convert object to proto representation."""
        return management_types_pb2.StringStats(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<StringStats object " + repr(self.to_dict()) + ">"


class CategoricalStats:
    """Categorical stats."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , column_name: str = ""
        , distinct_values: int = 0
        , null_count: int = 0
        , categorical_distribution: CategoricalDistribution = None
    , **kwargs) -> CategoricalStats:
        self._attributes = dict()
        self.column_name = column_name
        self.distinct_values = distinct_values
        self.null_count = null_count
        self.categorical_distribution = categorical_distribution

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def column_name(self) -> str:
        """Column name."""
        return self._attributes["column_name"]


    @column_name.setter
    def column_name(self, value: str) -> None:
        _set_attribute(self._attributes, "CategoricalStats", "column_name", value, str, "")


    @property
    def distinct_values(self) -> int:
        """Distinct values."""
        return self._attributes["distinct_values"]


    @distinct_values.setter
    def distinct_values(self, value: int) -> None:
        _set_attribute(self._attributes, "CategoricalStats", "distinct_values", value, int, "")


    @property
    def null_count(self) -> int:
        """Null count."""
        return self._attributes["null_count"]


    @null_count.setter
    def null_count(self, value: int) -> None:
        _set_attribute(self._attributes, "CategoricalStats", "null_count", value, int, "")


    @property
    def categorical_distribution(self) -> CategoricalDistribution:
        """Categorical distribution."""
        return self._attributes["categorical_distribution"]


    @categorical_distribution.setter
    def categorical_distribution(self, value: CategoricalDistribution) -> None:
        _set_attribute(self._attributes, "CategoricalStats", "categorical_distribution", value, CategoricalDistribution, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.CategoricalStats, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.CategoricalStats:
        """Convert object to proto representation."""
        return management_types_pb2.CategoricalStats(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<CategoricalStats object " + repr(self.to_dict()) + ">"


class TimestampStats:
    """Timestamp stats."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , column_name: str = ""
        , distinct_values: int = 0
        , null_count: int = 0
        , min: datetime = None
        , max: datetime = None
        , timestamp_histogram: TimestampHistogram = None
    , **kwargs) -> TimestampStats:
        self._attributes = dict()
        self.column_name = column_name
        self.distinct_values = distinct_values
        self.null_count = null_count
        self.min = min
        self.max = max
        self.timestamp_histogram = timestamp_histogram

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def column_name(self) -> str:
        """Column name."""
        return self._attributes["column_name"]


    @column_name.setter
    def column_name(self, value: str) -> None:
        _set_attribute(self._attributes, "TimestampStats", "column_name", value, str, "")


    @property
    def distinct_values(self) -> int:
        """Distinct values."""
        return self._attributes["distinct_values"]


    @distinct_values.setter
    def distinct_values(self, value: int) -> None:
        _set_attribute(self._attributes, "TimestampStats", "distinct_values", value, int, "")


    @property
    def null_count(self) -> int:
        """Null count."""
        return self._attributes["null_count"]


    @null_count.setter
    def null_count(self, value: int) -> None:
        _set_attribute(self._attributes, "TimestampStats", "null_count", value, int, "")


    @property
    def min(self) -> datetime:
        """Min."""
        return self._attributes["min"]


    @min.setter
    def min(self, value: datetime) -> None:
        _set_attribute(self._attributes, "TimestampStats", "min", value, datetime, "")


    @property
    def max(self) -> datetime:
        """Max."""
        return self._attributes["max"]


    @max.setter
    def max(self, value: datetime) -> None:
        _set_attribute(self._attributes, "TimestampStats", "max", value, datetime, "")


    @property
    def timestamp_histogram(self) -> TimestampHistogram:
        """Timestamp histogram."""
        return self._attributes["timestamp_histogram"]


    @timestamp_histogram.setter
    def timestamp_histogram(self, value: TimestampHistogram) -> None:
        _set_attribute(self._attributes, "TimestampStats", "timestamp_histogram", value, TimestampHistogram, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.TimestampStats, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.TimestampStats:
        """Convert object to proto representation."""
        return management_types_pb2.TimestampStats(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<TimestampStats object " + repr(self.to_dict()) + ">"


class NumericStats:
    """Numeric stats."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , column_name: str = ""
        , distinct_values: int = 0
        , min: float = 0.0
        , max: float = 0.0
        , sd: float = 0.0
        , mean: float = 0.0
        , count: int = 0
        , percentile25: float = 0.0
        , percentile50: float = 0.0
        , percentile75: float = 0.0
        , null_count: int = 0
        , num_nan: int = 0
        , num_values_histogram: Histogram = None
    , **kwargs) -> NumericStats:
        self._attributes = dict()
        self.column_name = column_name
        self.distinct_values = distinct_values
        self.min = min
        self.max = max
        self.sd = sd
        self.mean = mean
        self.count = count
        self.percentile25 = percentile25
        self.percentile50 = percentile50
        self.percentile75 = percentile75
        self.null_count = null_count
        self.num_nan = num_nan
        self.num_values_histogram = num_values_histogram

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def column_name(self) -> str:
        """Column name."""
        return self._attributes["column_name"]


    @column_name.setter
    def column_name(self, value: str) -> None:
        _set_attribute(self._attributes, "NumericStats", "column_name", value, str, "")


    @property
    def distinct_values(self) -> int:
        """Distinct values."""
        return self._attributes["distinct_values"]


    @distinct_values.setter
    def distinct_values(self, value: int) -> None:
        _set_attribute(self._attributes, "NumericStats", "distinct_values", value, int, "")


    @property
    def min(self) -> float:
        """Min."""
        return self._attributes["min"]


    @min.setter
    def min(self, value: float) -> None:
        _set_attribute(self._attributes, "NumericStats", "min", value, float, "")


    @property
    def max(self) -> float:
        """Max."""
        return self._attributes["max"]


    @max.setter
    def max(self, value: float) -> None:
        _set_attribute(self._attributes, "NumericStats", "max", value, float, "")


    @property
    def sd(self) -> float:
        """Sd."""
        return self._attributes["sd"]


    @sd.setter
    def sd(self, value: float) -> None:
        _set_attribute(self._attributes, "NumericStats", "sd", value, float, "")


    @property
    def mean(self) -> float:
        """Mean."""
        return self._attributes["mean"]


    @mean.setter
    def mean(self, value: float) -> None:
        _set_attribute(self._attributes, "NumericStats", "mean", value, float, "")


    @property
    def count(self) -> int:
        """Count."""
        return self._attributes["count"]


    @count.setter
    def count(self, value: int) -> None:
        _set_attribute(self._attributes, "NumericStats", "count", value, int, "")


    @property
    def percentile25(self) -> float:
        """Percentile25."""
        return self._attributes["percentile25"]


    @percentile25.setter
    def percentile25(self, value: float) -> None:
        _set_attribute(self._attributes, "NumericStats", "percentile25", value, float, "")


    @property
    def percentile50(self) -> float:
        """Percentile50."""
        return self._attributes["percentile50"]


    @percentile50.setter
    def percentile50(self, value: float) -> None:
        _set_attribute(self._attributes, "NumericStats", "percentile50", value, float, "")


    @property
    def percentile75(self) -> float:
        """Percentile75."""
        return self._attributes["percentile75"]


    @percentile75.setter
    def percentile75(self, value: float) -> None:
        _set_attribute(self._attributes, "NumericStats", "percentile75", value, float, "")


    @property
    def null_count(self) -> int:
        """Null count."""
        return self._attributes["null_count"]


    @null_count.setter
    def null_count(self, value: int) -> None:
        _set_attribute(self._attributes, "NumericStats", "null_count", value, int, "")


    @property
    def num_nan(self) -> int:
        """Num nan."""
        return self._attributes["num_nan"]


    @num_nan.setter
    def num_nan(self, value: int) -> None:
        _set_attribute(self._attributes, "NumericStats", "num_nan", value, int, "")


    @property
    def num_values_histogram(self) -> Histogram:
        """Num values histogram."""
        return self._attributes["num_values_histogram"]


    @num_values_histogram.setter
    def num_values_histogram(self, value: Histogram) -> None:
        _set_attribute(self._attributes, "NumericStats", "num_values_histogram", value, Histogram, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.NumericStats, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.NumericStats:
        """Convert object to proto representation."""
        return management_types_pb2.NumericStats(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<NumericStats object " + repr(self.to_dict()) + ">"


class BillingAccount:
    """Billing account."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , email: str = ""
        , memo: str = ""
        , update_time: datetime = None
        , create_time: datetime = None
    , **kwargs) -> BillingAccount:
        self._attributes = dict()
        self.name = name
        self.email = email
        self.memo = memo
        self.update_time = update_time
        self.create_time = create_time

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "BillingAccount", "name", value, str, "")


    @property
    def email(self) -> str:
        """Email."""
        return self._attributes["email"]


    @email.setter
    def email(self, value: str) -> None:
        _set_attribute(self._attributes, "BillingAccount", "email", value, str, "")


    @property
    def memo(self) -> str:
        """Memo."""
        return self._attributes["memo"]


    @memo.setter
    def memo(self, value: str) -> None:
        _set_attribute(self._attributes, "BillingAccount", "memo", value, str, "")


    @property
    def update_time(self) -> datetime:
        """Update time."""
        return self._attributes["update_time"]


    @update_time.setter
    def update_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "BillingAccount", "update_time", value, datetime, "")


    @property
    def create_time(self) -> datetime:
        """Create time."""
        return self._attributes["create_time"]


    @create_time.setter
    def create_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "BillingAccount", "create_time", value, datetime, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.BillingAccount, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.BillingAccount:
        """Convert object to proto representation."""
        return management_types_pb2.BillingAccount(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BillingAccount object " + repr(self.to_dict()) + ">"


class Subscription:
    """Subscription."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , price: str = ""
        , payment_method: str = ""
        , update_time: datetime = None
        , create_time: datetime = None
        , active: bool = False
    , **kwargs) -> Subscription:
        self._attributes = dict()
        self.name = name
        self.price = price
        self.payment_method = payment_method
        self.update_time = update_time
        self.create_time = create_time
        self.active = active

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "Subscription", "name", value, str, "")


    @property
    def price(self) -> str:
        """Price."""
        return self._attributes["price"]


    @price.setter
    def price(self, value: str) -> None:
        _set_attribute(self._attributes, "Subscription", "price", value, str, "")


    @property
    def payment_method(self) -> str:
        """Payment method."""
        return self._attributes["payment_method"]


    @payment_method.setter
    def payment_method(self, value: str) -> None:
        _set_attribute(self._attributes, "Subscription", "payment_method", value, str, "")


    @property
    def update_time(self) -> datetime:
        """Update time."""
        return self._attributes["update_time"]


    @update_time.setter
    def update_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Subscription", "update_time", value, datetime, "")


    @property
    def create_time(self) -> datetime:
        """Create time."""
        return self._attributes["create_time"]


    @create_time.setter
    def create_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Subscription", "create_time", value, datetime, "")


    @property
    def active(self) -> bool:
        """Active."""
        return self._attributes["active"]


    @active.setter
    def active(self, value: bool) -> None:
        _set_attribute(self._attributes, "Subscription", "active", value, bool, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.Subscription, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.Subscription:
        """Convert object to proto representation."""
        return management_types_pb2.Subscription(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<Subscription object " + repr(self.to_dict()) + ">"


class ProjectUsageRecord:
    """Project usage record."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , credits: int = 0
        , type_count: Dict[str, int] = None
    , **kwargs) -> ProjectUsageRecord:
        self._attributes = dict()
        self.name = name
        self.credits = credits
        self.type_count = type_count

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "ProjectUsageRecord", "name", value, str, "")


    @property
    def credits(self) -> int:
        """Credits."""
        return self._attributes["credits"]


    @credits.setter
    def credits(self, value: int) -> None:
        _set_attribute(self._attributes, "ProjectUsageRecord", "credits", value, int, "")


    @property
    def type_count(self) -> Dict[str, int]:
        """Type count."""
        return self._attributes["type_count"]


    @type_count.setter
    def type_count(self, value: Dict[str, int]) -> None:
        _set_attribute(self._attributes, "ProjectUsageRecord", "type_count", value, Dict[str, int], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.ProjectUsageRecord, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.ProjectUsageRecord:
        """Convert object to proto representation."""
        return management_types_pb2.ProjectUsageRecord(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ProjectUsageRecord object " + repr(self.to_dict()) + ">"


class CreditUsageRecord:
    """Credit usage record."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , period: datetime = None
        , credits: int = 0
        , project_usages: List[ProjectUsageRecord] = []
    , **kwargs) -> CreditUsageRecord:
        self._attributes = dict()
        self.period = period
        self.credits = credits
        self.project_usages = project_usages

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def period(self) -> datetime:
        """Period."""
        return self._attributes["period"]


    @period.setter
    def period(self, value: datetime) -> None:
        _set_attribute(self._attributes, "CreditUsageRecord", "period", value, datetime, "")


    @property
    def credits(self) -> int:
        """Credits."""
        return self._attributes["credits"]


    @credits.setter
    def credits(self, value: int) -> None:
        _set_attribute(self._attributes, "CreditUsageRecord", "credits", value, int, "")


    @property
    def project_usages(self) -> List[ProjectUsageRecord]:
        """Project usages."""
        return self._attributes["project_usages"]


    @project_usages.setter
    def project_usages(self, value: List[ProjectUsageRecord]) -> None:
        _set_attribute(self._attributes, "CreditUsageRecord", "project_usages", value, List[ProjectUsageRecord], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.CreditUsageRecord, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.CreditUsageRecord:
        """Convert object to proto representation."""
        return management_types_pb2.CreditUsageRecord(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<CreditUsageRecord object " + repr(self.to_dict()) + ">"


class InvoiceLineItem:
    """Invoice line item."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , id: str = ""
        , amount: int = 0
        , quantity: int = 0
        , currency: str = ""
        , description: str = ""
        , period_start: datetime = None
        , period_end: datetime = None
    , **kwargs) -> InvoiceLineItem:
        self._attributes = dict()
        self.id = id
        self.amount = amount
        self.quantity = quantity
        self.currency = currency
        self.description = description
        self.period_start = period_start
        self.period_end = period_end

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def id(self) -> str:
        """Id."""
        return self._attributes["id"]


    @id.setter
    def id(self, value: str) -> None:
        _set_attribute(self._attributes, "InvoiceLineItem", "id", value, str, "")


    @property
    def amount(self) -> int:
        """Amount."""
        return self._attributes["amount"]


    @amount.setter
    def amount(self, value: int) -> None:
        _set_attribute(self._attributes, "InvoiceLineItem", "amount", value, int, "")


    @property
    def quantity(self) -> int:
        """Quantity."""
        return self._attributes["quantity"]


    @quantity.setter
    def quantity(self, value: int) -> None:
        _set_attribute(self._attributes, "InvoiceLineItem", "quantity", value, int, "")


    @property
    def currency(self) -> str:
        """Currency."""
        return self._attributes["currency"]


    @currency.setter
    def currency(self, value: str) -> None:
        _set_attribute(self._attributes, "InvoiceLineItem", "currency", value, str, "")


    @property
    def description(self) -> str:
        """Description."""
        return self._attributes["description"]


    @description.setter
    def description(self, value: str) -> None:
        _set_attribute(self._attributes, "InvoiceLineItem", "description", value, str, "")


    @property
    def period_start(self) -> datetime:
        """Period start."""
        return self._attributes["period_start"]


    @period_start.setter
    def period_start(self, value: datetime) -> None:
        _set_attribute(self._attributes, "InvoiceLineItem", "period_start", value, datetime, "")


    @property
    def period_end(self) -> datetime:
        """Period end."""
        return self._attributes["period_end"]


    @period_end.setter
    def period_end(self, value: datetime) -> None:
        _set_attribute(self._attributes, "InvoiceLineItem", "period_end", value, datetime, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.InvoiceLineItem, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.InvoiceLineItem:
        """Convert object to proto representation."""
        return management_types_pb2.InvoiceLineItem(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<InvoiceLineItem object " + repr(self.to_dict()) + ">"


class Invoice:
    """Invoice."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , date: datetime = None
        , amount: int = 0
        , period_start: datetime = None
        , period_end: datetime = None
        , status: str = ""
        , invoice_url: str = ""
        , line_items: List[InvoiceLineItem] = []
    , **kwargs) -> Invoice:
        self._attributes = dict()
        self.name = name
        self.date = date
        self.amount = amount
        self.period_start = period_start
        self.period_end = period_end
        self.status = status
        self.invoice_url = invoice_url
        self.line_items = line_items

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "Invoice", "name", value, str, "")


    @property
    def date(self) -> datetime:
        """Date."""
        return self._attributes["date"]


    @date.setter
    def date(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Invoice", "date", value, datetime, "")


    @property
    def amount(self) -> int:
        """Amount."""
        return self._attributes["amount"]


    @amount.setter
    def amount(self, value: int) -> None:
        _set_attribute(self._attributes, "Invoice", "amount", value, int, "")


    @property
    def period_start(self) -> datetime:
        """Period start."""
        return self._attributes["period_start"]


    @period_start.setter
    def period_start(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Invoice", "period_start", value, datetime, "")


    @property
    def period_end(self) -> datetime:
        """Period end."""
        return self._attributes["period_end"]


    @period_end.setter
    def period_end(self, value: datetime) -> None:
        _set_attribute(self._attributes, "Invoice", "period_end", value, datetime, "")


    @property
    def status(self) -> str:
        """Status."""
        return self._attributes["status"]


    @status.setter
    def status(self, value: str) -> None:
        _set_attribute(self._attributes, "Invoice", "status", value, str, "")


    @property
    def invoice_url(self) -> str:
        """Invoice url."""
        return self._attributes["invoice_url"]


    @invoice_url.setter
    def invoice_url(self, value: str) -> None:
        _set_attribute(self._attributes, "Invoice", "invoice_url", value, str, "")


    @property
    def line_items(self) -> List[InvoiceLineItem]:
        """Line items."""
        return self._attributes["line_items"]


    @line_items.setter
    def line_items(self, value: List[InvoiceLineItem]) -> None:
        _set_attribute(self._attributes, "Invoice", "line_items", value, List[InvoiceLineItem], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.Invoice, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.Invoice:
        """Convert object to proto representation."""
        return management_types_pb2.Invoice(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<Invoice object " + repr(self.to_dict()) + ">"


class Price:
    """Price."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , title: str = ""
        , description: str = ""
        , direct_invoice: bool = False
    , **kwargs) -> Price:
        self._attributes = dict()
        self.name = name
        self.title = title
        self.description = description
        self.direct_invoice = direct_invoice

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "Price", "name", value, str, "")


    @property
    def title(self) -> str:
        """Title."""
        return self._attributes["title"]


    @title.setter
    def title(self, value: str) -> None:
        _set_attribute(self._attributes, "Price", "title", value, str, "")


    @property
    def description(self) -> str:
        """Description."""
        return self._attributes["description"]


    @description.setter
    def description(self, value: str) -> None:
        _set_attribute(self._attributes, "Price", "description", value, str, "")


    @property
    def direct_invoice(self) -> bool:
        """Direct invoice."""
        return self._attributes["direct_invoice"]


    @direct_invoice.setter
    def direct_invoice(self, value: bool) -> None:
        _set_attribute(self._attributes, "Price", "direct_invoice", value, bool, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.Price, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.Price:
        """Convert object to proto representation."""
        return management_types_pb2.Price(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<Price object " + repr(self.to_dict()) + ">"


class PaymentMethod:
    """Payment method."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , billing_details: PaymentMethodBillingDetails = None
        , card: PaymentMethodCard = None
    , **kwargs) -> PaymentMethod:
        self._attributes = dict()
        self.name = name
        self.billing_details = billing_details
        self.card = card

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "PaymentMethod", "name", value, str, "")


    @property
    def billing_details(self) -> PaymentMethodBillingDetails:
        """Billing details."""
        return self._attributes["billing_details"]


    @billing_details.setter
    def billing_details(self, value: PaymentMethodBillingDetails) -> None:
        _set_attribute(self._attributes, "PaymentMethod", "billing_details", value, PaymentMethodBillingDetails, "")


    @property
    def card(self) -> PaymentMethodCard:
        """Card."""
        return self._attributes["card"]


    @card.setter
    def card(self, value: PaymentMethodCard) -> None:
        _set_attribute(self._attributes, "PaymentMethod", "card", value, PaymentMethodCard, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.PaymentMethod, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.PaymentMethod:
        """Convert object to proto representation."""
        return management_types_pb2.PaymentMethod(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<PaymentMethod object " + repr(self.to_dict()) + ">"


class PaymentMethodBillingDetails:
    """Payment method billing details."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , postal_code: str = ""
    , **kwargs) -> PaymentMethodBillingDetails:
        self._attributes = dict()
        self.postal_code = postal_code

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def postal_code(self) -> str:
        """Postal code."""
        return self._attributes["postal_code"]


    @postal_code.setter
    def postal_code(self, value: str) -> None:
        _set_attribute(self._attributes, "PaymentMethodBillingDetails", "postal_code", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.PaymentMethod.BillingDetails, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.PaymentMethod.BillingDetails:
        """Convert object to proto representation."""
        return management_types_pb2.PaymentMethod.BillingDetails(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<PaymentMethodBillingDetails object " + repr(self.to_dict()) + ">"


class PaymentMethodCard:
    """Payment method card."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , brand: str = ""
        , last4: str = ""
        , exp_year: int = 0
        , exp_month: int = 0
    , **kwargs) -> PaymentMethodCard:
        self._attributes = dict()
        self.brand = brand
        self.last4 = last4
        self.exp_year = exp_year
        self.exp_month = exp_month

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def brand(self) -> str:
        """Brand."""
        return self._attributes["brand"]


    @brand.setter
    def brand(self, value: str) -> None:
        _set_attribute(self._attributes, "PaymentMethodCard", "brand", value, str, "")


    @property
    def last4(self) -> str:
        """Last4."""
        return self._attributes["last4"]


    @last4.setter
    def last4(self, value: str) -> None:
        _set_attribute(self._attributes, "PaymentMethodCard", "last4", value, str, "")


    @property
    def exp_year(self) -> int:
        """Exp year."""
        return self._attributes["exp_year"]


    @exp_year.setter
    def exp_year(self, value: int) -> None:
        _set_attribute(self._attributes, "PaymentMethodCard", "exp_year", value, int, "")


    @property
    def exp_month(self) -> int:
        """Exp month."""
        return self._attributes["exp_month"]


    @exp_month.setter
    def exp_month(self, value: int) -> None:
        _set_attribute(self._attributes, "PaymentMethodCard", "exp_month", value, int, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.PaymentMethod.Card, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.PaymentMethod.Card:
        """Convert object to proto representation."""
        return management_types_pb2.PaymentMethod.Card(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<PaymentMethodCard object " + repr(self.to_dict()) + ">"


class DataChecks:
    """Data checks."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , results: List[DataChecksDataValidationResult] = []
    , **kwargs) -> DataChecks:
        self._attributes = dict()
        self.results = results

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def results(self) -> List[DataChecksDataValidationResult]:
        """Results."""
        return self._attributes["results"]


    @results.setter
    def results(self, value: List[DataChecksDataValidationResult]) -> None:
        _set_attribute(self._attributes, "DataChecks", "results", value, List[DataChecksDataValidationResult], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.DataChecks, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.DataChecks:
        """Convert object to proto representation."""
        return management_types_pb2.DataChecks(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<DataChecks object " + repr(self.to_dict()) + ">"


class DataChecksDataValidationResult:
    """Data checks data validation result."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , summary: str = ""
        , success: bool = False
        , duration: float = 0.0
        , errors: List[str] = []
        , warnings: List[str] = []
        , infos: List[str] = []
    , **kwargs) -> DataChecksDataValidationResult:
        self._attributes = dict()
        self.summary = summary
        self.success = success
        self.duration = duration
        self.errors = errors
        self.warnings = warnings
        self.infos = infos

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def summary(self) -> str:
        """summary of the test result"""
        return self._attributes["summary"]


    @summary.setter
    def summary(self, value: str) -> None:
        _set_attribute(self._attributes, "DataChecksDataValidationResult", "summary", value, str, "")


    @property
    def success(self) -> bool:
        """status of the test"""
        return self._attributes["success"]


    @success.setter
    def success(self, value: bool) -> None:
        _set_attribute(self._attributes, "DataChecksDataValidationResult", "success", value, bool, "")


    @property
    def duration(self) -> float:
        """Time taken to complete check in seconds"""
        return self._attributes["duration"]


    @duration.setter
    def duration(self, value: float) -> None:
        _set_attribute(self._attributes, "DataChecksDataValidationResult", "duration", value, float, "")


    @property
    def errors(self) -> List[str]:
        """list of strings containing error 
 messages or warnings if any"""
        return self._attributes["errors"]


    @errors.setter
    def errors(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "DataChecksDataValidationResult", "errors", value, List[str], "")


    @property
    def warnings(self) -> List[str]:
        """Warnings."""
        return self._attributes["warnings"]


    @warnings.setter
    def warnings(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "DataChecksDataValidationResult", "warnings", value, List[str], "")


    @property
    def infos(self) -> List[str]:
        """Infos."""
        return self._attributes["infos"]


    @infos.setter
    def infos(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "DataChecksDataValidationResult", "infos", value, List[str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_types_pb2.DataChecks.DataValidationResult, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_types_pb2.DataChecks.DataValidationResult:
        """Convert object to proto representation."""
        return management_types_pb2.DataChecks.DataValidationResult(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<DataChecksDataValidationResult object " + repr(self.to_dict()) + ">"


class UpdateUserRequest:
    """Update user request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , user: User = None
        , update_mask: protobuf.FieldMask = None
    , **kwargs) -> UpdateUserRequest:
        self._attributes = dict()
        self.user = user
        self.update_mask = update_mask

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def user(self) -> User:
        """User."""
        return self._attributes["user"]


    @user.setter
    def user(self, value: User) -> None:
        _set_attribute(self._attributes, "UpdateUserRequest", "user", value, User, "")


    @property
    def update_mask(self) -> protobuf.FieldMask:
        """Update mask."""
        return self._attributes["update_mask"]


    @update_mask.setter
    def update_mask(self, value: protobuf.FieldMask) -> None:
        _set_attribute(self._attributes, "UpdateUserRequest", "update_mask", value, protobuf.FieldMask, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.UpdateUserRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.UpdateUserRequest:
        """Convert object to proto representation."""
        return management_pb2.UpdateUserRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<UpdateUserRequest object " + repr(self.to_dict()) + ">"


class GetUserRequest:
    """Get user request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetUserRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetUserRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetUserRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetUserRequest:
        """Convert object to proto representation."""
        return management_pb2.GetUserRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetUserRequest object " + repr(self.to_dict()) + ">"


class BatchGetUsersRequest:
    """Batch get users request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , names: List[str] = []
    , **kwargs) -> BatchGetUsersRequest:
        self._attributes = dict()
        self.names = names

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def names(self) -> List[str]:
        """Names."""
        return self._attributes["names"]


    @names.setter
    def names(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "BatchGetUsersRequest", "names", value, List[str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BatchGetUsersRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BatchGetUsersRequest:
        """Convert object to proto representation."""
        return management_pb2.BatchGetUsersRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchGetUsersRequest object " + repr(self.to_dict()) + ">"


class BatchGetUsersResponse:
    """Batch get users response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , users: List[User] = []
    , **kwargs) -> BatchGetUsersResponse:
        self._attributes = dict()
        self.users = users

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def users(self) -> List[User]:
        """Users."""
        return self._attributes["users"]


    @users.setter
    def users(self, value: List[User]) -> None:
        _set_attribute(self._attributes, "BatchGetUsersResponse", "users", value, List[User], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BatchGetUsersResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BatchGetUsersResponse:
        """Convert object to proto representation."""
        return management_pb2.BatchGetUsersResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchGetUsersResponse object " + repr(self.to_dict()) + ">"


class DeleteUserRequest:
    """Delete user request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> DeleteUserRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "DeleteUserRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.DeleteUserRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.DeleteUserRequest:
        """Convert object to proto representation."""
        return management_pb2.DeleteUserRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<DeleteUserRequest object " + repr(self.to_dict()) + ">"


class ListUsersRequest:
    """List users request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , page_size: int = 0
        , page_token: str = ""
    , **kwargs) -> ListUsersRequest:
        self._attributes = dict()
        self.page_size = page_size
        self.page_token = page_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def page_size(self) -> int:
        """Page size."""
        return self._attributes["page_size"]


    @page_size.setter
    def page_size(self, value: int) -> None:
        _set_attribute(self._attributes, "ListUsersRequest", "page_size", value, int, "")


    @property
    def page_token(self) -> str:
        """Page token."""
        return self._attributes["page_token"]


    @page_token.setter
    def page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListUsersRequest", "page_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListUsersRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListUsersRequest:
        """Convert object to proto representation."""
        return management_pb2.ListUsersRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListUsersRequest object " + repr(self.to_dict()) + ">"


class ListUsersResponse:
    """List users response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , users: List[User] = []
        , next_page_token: str = ""
    , **kwargs) -> ListUsersResponse:
        self._attributes = dict()
        self.users = users
        self.next_page_token = next_page_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def users(self) -> List[User]:
        """Users."""
        return self._attributes["users"]


    @users.setter
    def users(self, value: List[User]) -> None:
        _set_attribute(self._attributes, "ListUsersResponse", "users", value, List[User], "")


    @property
    def next_page_token(self) -> str:
        """Next page token."""
        return self._attributes["next_page_token"]


    @next_page_token.setter
    def next_page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListUsersResponse", "next_page_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListUsersResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListUsersResponse:
        """Convert object to proto representation."""
        return management_pb2.ListUsersResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListUsersResponse object " + repr(self.to_dict()) + ">"


class RegisterRequest:
    """Register request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , full_name: str = ""
        , email: str = ""
        , password: str = ""
        , first_name: str = ""
        , last_name: str = ""
    , **kwargs) -> RegisterRequest:
        self._attributes = dict()
        self.full_name = full_name
        self.email = email
        self.password = password
        self.first_name = first_name
        self.last_name = last_name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def full_name(self) -> str:
        """Full name."""
        return self._attributes["full_name"]


    @full_name.setter
    def full_name(self, value: str) -> None:
        _set_attribute(self._attributes, "RegisterRequest", "full_name", value, str, "")


    @property
    def email(self) -> str:
        """Email."""
        return self._attributes["email"]


    @email.setter
    def email(self, value: str) -> None:
        _set_attribute(self._attributes, "RegisterRequest", "email", value, str, "")


    @property
    def password(self) -> str:
        """Password."""
        return self._attributes["password"]


    @password.setter
    def password(self, value: str) -> None:
        _set_attribute(self._attributes, "RegisterRequest", "password", value, str, "")


    @property
    def first_name(self) -> str:
        """First name."""
        return self._attributes["first_name"]


    @first_name.setter
    def first_name(self, value: str) -> None:
        _set_attribute(self._attributes, "RegisterRequest", "first_name", value, str, "")


    @property
    def last_name(self) -> str:
        """Last name."""
        return self._attributes["last_name"]


    @last_name.setter
    def last_name(self, value: str) -> None:
        _set_attribute(self._attributes, "RegisterRequest", "last_name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.RegisterRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.RegisterRequest:
        """Convert object to proto representation."""
        return management_pb2.RegisterRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<RegisterRequest object " + repr(self.to_dict()) + ">"


class RegisterResponse:
    """Register response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , user: User = None
        , auth_token: str = ""
    , **kwargs) -> RegisterResponse:
        self._attributes = dict()
        self.user = user
        self.auth_token = auth_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def user(self) -> User:
        """User."""
        return self._attributes["user"]


    @user.setter
    def user(self, value: User) -> None:
        _set_attribute(self._attributes, "RegisterResponse", "user", value, User, "")


    @property
    def auth_token(self) -> str:
        """Auth token."""
        return self._attributes["auth_token"]


    @auth_token.setter
    def auth_token(self, value: str) -> None:
        _set_attribute(self._attributes, "RegisterResponse", "auth_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.RegisterResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.RegisterResponse:
        """Convert object to proto representation."""
        return management_pb2.RegisterResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<RegisterResponse object " + repr(self.to_dict()) + ">"


class LoginRequest:
    """Login request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , email: str = ""
        , password: str = ""
    , **kwargs) -> LoginRequest:
        self._attributes = dict()
        self.email = email
        self.password = password

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def email(self) -> str:
        """Email."""
        return self._attributes["email"]


    @email.setter
    def email(self, value: str) -> None:
        _set_attribute(self._attributes, "LoginRequest", "email", value, str, "")


    @property
    def password(self) -> str:
        """Password."""
        return self._attributes["password"]


    @password.setter
    def password(self, value: str) -> None:
        _set_attribute(self._attributes, "LoginRequest", "password", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.LoginRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.LoginRequest:
        """Convert object to proto representation."""
        return management_pb2.LoginRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<LoginRequest object " + repr(self.to_dict()) + ">"


class LoginResponse:
    """Login response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , user: User = None
        , auth_token: str = ""
    , **kwargs) -> LoginResponse:
        self._attributes = dict()
        self.user = user
        self.auth_token = auth_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def user(self) -> User:
        """User."""
        return self._attributes["user"]


    @user.setter
    def user(self, value: User) -> None:
        _set_attribute(self._attributes, "LoginResponse", "user", value, User, "")


    @property
    def auth_token(self) -> str:
        """Auth token."""
        return self._attributes["auth_token"]


    @auth_token.setter
    def auth_token(self, value: str) -> None:
        _set_attribute(self._attributes, "LoginResponse", "auth_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.LoginResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.LoginResponse:
        """Convert object to proto representation."""
        return management_pb2.LoginResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<LoginResponse object " + repr(self.to_dict()) + ">"


class SendEmailVerificationRequest:
    """Send email verification request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , user: str = ""
    , **kwargs) -> SendEmailVerificationRequest:
        self._attributes = dict()
        self.user = user

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def user(self) -> str:
        """User."""
        return self._attributes["user"]


    @user.setter
    def user(self, value: str) -> None:
        _set_attribute(self._attributes, "SendEmailVerificationRequest", "user", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.SendEmailVerificationRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.SendEmailVerificationRequest:
        """Convert object to proto representation."""
        return management_pb2.SendEmailVerificationRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<SendEmailVerificationRequest object " + repr(self.to_dict()) + ">"


class VerifyEmailRequest:
    """Verify email request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , user: str = ""
        , code: str = ""
    , **kwargs) -> VerifyEmailRequest:
        self._attributes = dict()
        self.user = user
        self.code = code

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def user(self) -> str:
        """User."""
        return self._attributes["user"]


    @user.setter
    def user(self, value: str) -> None:
        _set_attribute(self._attributes, "VerifyEmailRequest", "user", value, str, "")


    @property
    def code(self) -> str:
        """Code."""
        return self._attributes["code"]


    @code.setter
    def code(self, value: str) -> None:
        _set_attribute(self._attributes, "VerifyEmailRequest", "code", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.VerifyEmailRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.VerifyEmailRequest:
        """Convert object to proto representation."""
        return management_pb2.VerifyEmailRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<VerifyEmailRequest object " + repr(self.to_dict()) + ">"


class VerifyEmailResponse:
    """Verify email response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , success: bool = False
    , **kwargs) -> VerifyEmailResponse:
        self._attributes = dict()
        self.success = success

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def success(self) -> bool:
        """Success."""
        return self._attributes["success"]


    @success.setter
    def success(self, value: bool) -> None:
        _set_attribute(self._attributes, "VerifyEmailResponse", "success", value, bool, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.VerifyEmailResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.VerifyEmailResponse:
        """Convert object to proto representation."""
        return management_pb2.VerifyEmailResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<VerifyEmailResponse object " + repr(self.to_dict()) + ">"


class SendPasswordResetRequest:
    """Send password reset request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , email: str = ""
    , **kwargs) -> SendPasswordResetRequest:
        self._attributes = dict()
        self.email = email

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def email(self) -> str:
        """Email."""
        return self._attributes["email"]


    @email.setter
    def email(self, value: str) -> None:
        _set_attribute(self._attributes, "SendPasswordResetRequest", "email", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.SendPasswordResetRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.SendPasswordResetRequest:
        """Convert object to proto representation."""
        return management_pb2.SendPasswordResetRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<SendPasswordResetRequest object " + repr(self.to_dict()) + ">"


class GetPasswordResetRequest:
    """Get password reset request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , code: str = ""
    , **kwargs) -> GetPasswordResetRequest:
        self._attributes = dict()
        self.code = code

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def code(self) -> str:
        """Code."""
        return self._attributes["code"]


    @code.setter
    def code(self, value: str) -> None:
        _set_attribute(self._attributes, "GetPasswordResetRequest", "code", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetPasswordResetRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetPasswordResetRequest:
        """Convert object to proto representation."""
        return management_pb2.GetPasswordResetRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetPasswordResetRequest object " + repr(self.to_dict()) + ">"


class ResetPasswordRequest:
    """Reset password request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , password: str = ""
        , code: str = ""
    , **kwargs) -> ResetPasswordRequest:
        self._attributes = dict()
        self.password = password
        self.code = code

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def password(self) -> str:
        """Password."""
        return self._attributes["password"]


    @password.setter
    def password(self, value: str) -> None:
        _set_attribute(self._attributes, "ResetPasswordRequest", "password", value, str, "")


    @property
    def code(self) -> str:
        """Code."""
        return self._attributes["code"]


    @code.setter
    def code(self, value: str) -> None:
        _set_attribute(self._attributes, "ResetPasswordRequest", "code", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ResetPasswordRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ResetPasswordRequest:
        """Convert object to proto representation."""
        return management_pb2.ResetPasswordRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ResetPasswordRequest object " + repr(self.to_dict()) + ">"


class ResetPasswordResponse:
    """Reset password response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , success: bool = False
    , **kwargs) -> ResetPasswordResponse:
        self._attributes = dict()
        self.success = success

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def success(self) -> bool:
        """Success."""
        return self._attributes["success"]


    @success.setter
    def success(self, value: bool) -> None:
        _set_attribute(self._attributes, "ResetPasswordResponse", "success", value, bool, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ResetPasswordResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ResetPasswordResponse:
        """Convert object to proto representation."""
        return management_pb2.ResetPasswordResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ResetPasswordResponse object " + repr(self.to_dict()) + ">"


class GetSessionRequest:
    """Get session request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetSessionRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetSessionRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetSessionRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetSessionRequest:
        """Convert object to proto representation."""
        return management_pb2.GetSessionRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetSessionRequest object " + repr(self.to_dict()) + ">"


class ListSessionsRequest:
    """List sessions request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , page_size: int = 0
        , page_token: str = ""
    , **kwargs) -> ListSessionsRequest:
        self._attributes = dict()
        self.parent = parent
        self.page_size = page_size
        self.page_token = page_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "ListSessionsRequest", "parent", value, str, "")


    @property
    def page_size(self) -> int:
        """Page size."""
        return self._attributes["page_size"]


    @page_size.setter
    def page_size(self, value: int) -> None:
        _set_attribute(self._attributes, "ListSessionsRequest", "page_size", value, int, "")


    @property
    def page_token(self) -> str:
        """Page token."""
        return self._attributes["page_token"]


    @page_token.setter
    def page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListSessionsRequest", "page_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListSessionsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListSessionsRequest:
        """Convert object to proto representation."""
        return management_pb2.ListSessionsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListSessionsRequest object " + repr(self.to_dict()) + ">"


class ListSessionsResponse:
    """List sessions response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , sessions: List[Session] = []
        , next_page_token: str = ""
    , **kwargs) -> ListSessionsResponse:
        self._attributes = dict()
        self.sessions = sessions
        self.next_page_token = next_page_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def sessions(self) -> List[Session]:
        """Sessions."""
        return self._attributes["sessions"]


    @sessions.setter
    def sessions(self, value: List[Session]) -> None:
        _set_attribute(self._attributes, "ListSessionsResponse", "sessions", value, List[Session], "")


    @property
    def next_page_token(self) -> str:
        """Next page token."""
        return self._attributes["next_page_token"]


    @next_page_token.setter
    def next_page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListSessionsResponse", "next_page_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListSessionsResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListSessionsResponse:
        """Convert object to proto representation."""
        return management_pb2.ListSessionsResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListSessionsResponse object " + repr(self.to_dict()) + ">"


class DeleteSessionRequest:
    """Delete session request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> DeleteSessionRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "DeleteSessionRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.DeleteSessionRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.DeleteSessionRequest:
        """Convert object to proto representation."""
        return management_pb2.DeleteSessionRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<DeleteSessionRequest object " + repr(self.to_dict()) + ">"


class DeleteAllSessionsRequest:
    """Delete all sessions request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
    , **kwargs) -> DeleteAllSessionsRequest:
        self._attributes = dict()
        self.parent = parent

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "DeleteAllSessionsRequest", "parent", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.DeleteAllSessionsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.DeleteAllSessionsRequest:
        """Convert object to proto representation."""
        return management_pb2.DeleteAllSessionsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<DeleteAllSessionsRequest object " + repr(self.to_dict()) + ">"


class ListRolesRequest:
    """The request to get all roles defined for a resource."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , page_size: int = 0
        , page_token: str = ""
    , **kwargs) -> ListRolesRequest:
        self._attributes = dict()
        self.page_size = page_size
        self.page_token = page_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def page_size(self) -> int:
        """Optional limit on the number of roles to include in the response."""
        return self._attributes["page_size"]


    @page_size.setter
    def page_size(self, value: int) -> None:
        _set_attribute(self._attributes, "ListRolesRequest", "page_size", value, int, "")


    @property
    def page_token(self) -> str:
        """Optional pagination token returned in an earlier ListRolesResponse."""
        return self._attributes["page_token"]


    @page_token.setter
    def page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListRolesRequest", "page_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListRolesRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListRolesRequest:
        """Convert object to proto representation."""
        return management_pb2.ListRolesRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListRolesRequest object " + repr(self.to_dict()) + ">"


class ListRolesResponse:
    """The response containing the roles defined under a resource."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , roles: List[Role] = []
        , next_page_token: str = ""
    , **kwargs) -> ListRolesResponse:
        self._attributes = dict()
        self.roles = roles
        self.next_page_token = next_page_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def roles(self) -> List[Role]:
        """The Roles defined on this resource."""
        return self._attributes["roles"]


    @roles.setter
    def roles(self, value: List[Role]) -> None:
        _set_attribute(self._attributes, "ListRolesResponse", "roles", value, List[Role], "")


    @property
    def next_page_token(self) -> str:
        """To retrieve the next page of results, set
 `ListRolesRequest.page_token` to this value."""
        return self._attributes["next_page_token"]


    @next_page_token.setter
    def next_page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListRolesResponse", "next_page_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListRolesResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListRolesResponse:
        """Convert object to proto representation."""
        return management_pb2.ListRolesResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListRolesResponse object " + repr(self.to_dict()) + ">"


class GetRoleRequest:
    """The request to get the definition of an existing role."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetRoleRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """The resource name of the role in one of the following formats:
 `roles/{ROLE_NAME}`"""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetRoleRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetRoleRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetRoleRequest:
        """Convert object to proto representation."""
        return management_pb2.GetRoleRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetRoleRequest object " + repr(self.to_dict()) + ">"


class BatchGetRolesRequest:
    """Batch get roles request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , names: List[str] = []
    , **kwargs) -> BatchGetRolesRequest:
        self._attributes = dict()
        self.parent = parent
        self.names = names

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "BatchGetRolesRequest", "parent", value, str, "")


    @property
    def names(self) -> List[str]:
        """Names."""
        return self._attributes["names"]


    @names.setter
    def names(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "BatchGetRolesRequest", "names", value, List[str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BatchGetRolesRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BatchGetRolesRequest:
        """Convert object to proto representation."""
        return management_pb2.BatchGetRolesRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchGetRolesRequest object " + repr(self.to_dict()) + ">"


class BatchGetRolesResponse:
    """Batch get roles response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , roles: List[Role] = []
    , **kwargs) -> BatchGetRolesResponse:
        self._attributes = dict()
        self.roles = roles

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def roles(self) -> List[Role]:
        """Roles."""
        return self._attributes["roles"]


    @roles.setter
    def roles(self, value: List[Role]) -> None:
        _set_attribute(self._attributes, "BatchGetRolesResponse", "roles", value, List[Role], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BatchGetRolesResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BatchGetRolesResponse:
        """Convert object to proto representation."""
        return management_pb2.BatchGetRolesResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchGetRolesResponse object " + repr(self.to_dict()) + ">"


class ListAccessPoliciesRequest:
    """List access policies request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , page_size: int = 0
        , page_token: str = ""
    , **kwargs) -> ListAccessPoliciesRequest:
        self._attributes = dict()
        self.parent = parent
        self.page_size = page_size
        self.page_token = page_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent resource for access policies."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "ListAccessPoliciesRequest", "parent", value, str, "")


    @property
    def page_size(self) -> int:
        """Optional limit on the number of items to include in the response."""
        return self._attributes["page_size"]


    @page_size.setter
    def page_size(self, value: int) -> None:
        _set_attribute(self._attributes, "ListAccessPoliciesRequest", "page_size", value, int, "")


    @property
    def page_token(self) -> str:
        """Optional pagination token returned in an earlier ListAccessPolicies."""
        return self._attributes["page_token"]


    @page_token.setter
    def page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListAccessPoliciesRequest", "page_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListAccessPoliciesRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListAccessPoliciesRequest:
        """Convert object to proto representation."""
        return management_pb2.ListAccessPoliciesRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListAccessPoliciesRequest object " + repr(self.to_dict()) + ">"


class ListAccessPoliciesResponse:
    """List access policies response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , access_policies: List[AccessPolicy] = []
        , next_page_token: str = ""
    , **kwargs) -> ListAccessPoliciesResponse:
        self._attributes = dict()
        self.access_policies = access_policies
        self.next_page_token = next_page_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def access_policies(self) -> List[AccessPolicy]:
        """List of access policies attached to resource."""
        return self._attributes["access_policies"]


    @access_policies.setter
    def access_policies(self, value: List[AccessPolicy]) -> None:
        _set_attribute(self._attributes, "ListAccessPoliciesResponse", "access_policies", value, List[AccessPolicy], "")


    @property
    def next_page_token(self) -> str:
        """To retrieve the next page of results, set
 `ListAccessPoliciesRequest.page_token` to this value."""
        return self._attributes["next_page_token"]


    @next_page_token.setter
    def next_page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListAccessPoliciesResponse", "next_page_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListAccessPoliciesResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListAccessPoliciesResponse:
        """Convert object to proto representation."""
        return management_pb2.ListAccessPoliciesResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListAccessPoliciesResponse object " + repr(self.to_dict()) + ">"


class CreateAccessPolicyRequest:
    """Create access policy request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , access_policy: AccessPolicy = None
    , **kwargs) -> CreateAccessPolicyRequest:
        self._attributes = dict()
        self.parent = parent
        self.access_policy = access_policy

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent resource on which to create access policy."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "CreateAccessPolicyRequest", "parent", value, str, "")


    @property
    def access_policy(self) -> AccessPolicy:
        """Access policy to create."""
        return self._attributes["access_policy"]


    @access_policy.setter
    def access_policy(self, value: AccessPolicy) -> None:
        _set_attribute(self._attributes, "CreateAccessPolicyRequest", "access_policy", value, AccessPolicy, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.CreateAccessPolicyRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.CreateAccessPolicyRequest:
        """Convert object to proto representation."""
        return management_pb2.CreateAccessPolicyRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<CreateAccessPolicyRequest object " + repr(self.to_dict()) + ">"


class GetAccessPolicyRequest:
    """Get access policy request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetAccessPolicyRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name of access policy."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetAccessPolicyRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetAccessPolicyRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetAccessPolicyRequest:
        """Convert object to proto representation."""
        return management_pb2.GetAccessPolicyRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetAccessPolicyRequest object " + repr(self.to_dict()) + ">"


class UpdateAccessPolicyRequest:
    """Update access policy request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , access_policy: AccessPolicy = None
        , update_mask: protobuf.FieldMask = None
    , **kwargs) -> UpdateAccessPolicyRequest:
        self._attributes = dict()
        self.access_policy = access_policy
        self.update_mask = update_mask

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def access_policy(self) -> AccessPolicy:
        """Access policy."""
        return self._attributes["access_policy"]


    @access_policy.setter
    def access_policy(self, value: AccessPolicy) -> None:
        _set_attribute(self._attributes, "UpdateAccessPolicyRequest", "access_policy", value, AccessPolicy, "")


    @property
    def update_mask(self) -> protobuf.FieldMask:
        """Update mask."""
        return self._attributes["update_mask"]


    @update_mask.setter
    def update_mask(self, value: protobuf.FieldMask) -> None:
        _set_attribute(self._attributes, "UpdateAccessPolicyRequest", "update_mask", value, protobuf.FieldMask, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.UpdateAccessPolicyRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.UpdateAccessPolicyRequest:
        """Convert object to proto representation."""
        return management_pb2.UpdateAccessPolicyRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<UpdateAccessPolicyRequest object " + repr(self.to_dict()) + ">"


class DeleteAccessPolicyRequest:
    """Delete access policy request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> DeleteAccessPolicyRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name of access policy."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "DeleteAccessPolicyRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.DeleteAccessPolicyRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.DeleteAccessPolicyRequest:
        """Convert object to proto representation."""
        return management_pb2.DeleteAccessPolicyRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<DeleteAccessPolicyRequest object " + repr(self.to_dict()) + ">"


class CreateInviteRequest:
    """Create invite request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , invite: Invite = None
    , **kwargs) -> CreateInviteRequest:
        self._attributes = dict()
        self.parent = parent
        self.invite = invite

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "CreateInviteRequest", "parent", value, str, "")


    @property
    def invite(self) -> Invite:
        """Invite."""
        return self._attributes["invite"]


    @invite.setter
    def invite(self, value: Invite) -> None:
        _set_attribute(self._attributes, "CreateInviteRequest", "invite", value, Invite, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.CreateInviteRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.CreateInviteRequest:
        """Convert object to proto representation."""
        return management_pb2.CreateInviteRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<CreateInviteRequest object " + repr(self.to_dict()) + ">"


class GetInviteRequest:
    """Get invite request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetInviteRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetInviteRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetInviteRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetInviteRequest:
        """Convert object to proto representation."""
        return management_pb2.GetInviteRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetInviteRequest object " + repr(self.to_dict()) + ">"


class ListInvitesRequest:
    """List invites request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , page_token: str = ""
        , page_size: int = 0
    , **kwargs) -> ListInvitesRequest:
        self._attributes = dict()
        self.parent = parent
        self.page_token = page_token
        self.page_size = page_size

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "ListInvitesRequest", "parent", value, str, "")


    @property
    def page_token(self) -> str:
        """Page token."""
        return self._attributes["page_token"]


    @page_token.setter
    def page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListInvitesRequest", "page_token", value, str, "")


    @property
    def page_size(self) -> int:
        """Page size."""
        return self._attributes["page_size"]


    @page_size.setter
    def page_size(self, value: int) -> None:
        _set_attribute(self._attributes, "ListInvitesRequest", "page_size", value, int, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListInvitesRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListInvitesRequest:
        """Convert object to proto representation."""
        return management_pb2.ListInvitesRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListInvitesRequest object " + repr(self.to_dict()) + ">"


class ListInvitesResponse:
    """List invites response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , invites: List[Invite] = []
        , next_page_token: str = ""
    , **kwargs) -> ListInvitesResponse:
        self._attributes = dict()
        self.invites = invites
        self.next_page_token = next_page_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def invites(self) -> List[Invite]:
        """Invites."""
        return self._attributes["invites"]


    @invites.setter
    def invites(self, value: List[Invite]) -> None:
        _set_attribute(self._attributes, "ListInvitesResponse", "invites", value, List[Invite], "")


    @property
    def next_page_token(self) -> str:
        """Next page token."""
        return self._attributes["next_page_token"]


    @next_page_token.setter
    def next_page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListInvitesResponse", "next_page_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListInvitesResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListInvitesResponse:
        """Convert object to proto representation."""
        return management_pb2.ListInvitesResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListInvitesResponse object " + repr(self.to_dict()) + ">"


class UpdateInviteRequest:
    """Update invite request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , invite: Invite = None
        , update_mask: protobuf.FieldMask = None
    , **kwargs) -> UpdateInviteRequest:
        self._attributes = dict()
        self.invite = invite
        self.update_mask = update_mask

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def invite(self) -> Invite:
        """Invite."""
        return self._attributes["invite"]


    @invite.setter
    def invite(self, value: Invite) -> None:
        _set_attribute(self._attributes, "UpdateInviteRequest", "invite", value, Invite, "")


    @property
    def update_mask(self) -> protobuf.FieldMask:
        """Update mask."""
        return self._attributes["update_mask"]


    @update_mask.setter
    def update_mask(self, value: protobuf.FieldMask) -> None:
        _set_attribute(self._attributes, "UpdateInviteRequest", "update_mask", value, protobuf.FieldMask, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.UpdateInviteRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.UpdateInviteRequest:
        """Convert object to proto representation."""
        return management_pb2.UpdateInviteRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<UpdateInviteRequest object " + repr(self.to_dict()) + ">"


class DeleteInviteRequest:
    """Delete invite request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> DeleteInviteRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "DeleteInviteRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.DeleteInviteRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.DeleteInviteRequest:
        """Convert object to proto representation."""
        return management_pb2.DeleteInviteRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<DeleteInviteRequest object " + repr(self.to_dict()) + ">"


class AcceptInviteRequest:
    """Accept invite request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , code: str = ""
    , **kwargs) -> AcceptInviteRequest:
        self._attributes = dict()
        self.code = code

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def code(self) -> str:
        """Code."""
        return self._attributes["code"]


    @code.setter
    def code(self, value: str) -> None:
        _set_attribute(self._attributes, "AcceptInviteRequest", "code", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.AcceptInviteRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.AcceptInviteRequest:
        """Convert object to proto representation."""
        return management_pb2.AcceptInviteRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<AcceptInviteRequest object " + repr(self.to_dict()) + ">"


class ResendInviteRequest:
    """Resend invite request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> ResendInviteRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "ResendInviteRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ResendInviteRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ResendInviteRequest:
        """Convert object to proto representation."""
        return management_pb2.ResendInviteRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ResendInviteRequest object " + repr(self.to_dict()) + ">"


class TestPermissionsRequest:
    """Test permissions request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , resource: str = ""
        , permissions: List[str] = []
    , **kwargs) -> TestPermissionsRequest:
        self._attributes = dict()
        self.resource = resource
        self.permissions = permissions

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def resource(self) -> str:
        """Resource on which to test permissions."""
        return self._attributes["resource"]


    @resource.setter
    def resource(self, value: str) -> None:
        _set_attribute(self._attributes, "TestPermissionsRequest", "resource", value, str, "")


    @property
    def permissions(self) -> List[str]:
        """Set of permissions to check for `resource`."""
        return self._attributes["permissions"]


    @permissions.setter
    def permissions(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "TestPermissionsRequest", "permissions", value, List[str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.TestPermissionsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.TestPermissionsRequest:
        """Convert object to proto representation."""
        return management_pb2.TestPermissionsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<TestPermissionsRequest object " + repr(self.to_dict()) + ">"


class TestPermissionsResponse:
    """Test permissions response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , permissions: List[str] = []
    , **kwargs) -> TestPermissionsResponse:
        self._attributes = dict()
        self.permissions = permissions

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def permissions(self) -> List[str]:
        """A subset of `TestPermissionsRequest.permissions` that the caller is
 allowed."""
        return self._attributes["permissions"]


    @permissions.setter
    def permissions(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "TestPermissionsResponse", "permissions", value, List[str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.TestPermissionsResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.TestPermissionsResponse:
        """Convert object to proto representation."""
        return management_pb2.TestPermissionsResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<TestPermissionsResponse object " + repr(self.to_dict()) + ">"


class CreateOrganizationRequest:
    """Create organization request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , organization: Organization = None
    , **kwargs) -> CreateOrganizationRequest:
        self._attributes = dict()
        self.organization = organization

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def organization(self) -> Organization:
        """Organization."""
        return self._attributes["organization"]


    @organization.setter
    def organization(self, value: Organization) -> None:
        _set_attribute(self._attributes, "CreateOrganizationRequest", "organization", value, Organization, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.CreateOrganizationRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.CreateOrganizationRequest:
        """Convert object to proto representation."""
        return management_pb2.CreateOrganizationRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<CreateOrganizationRequest object " + repr(self.to_dict()) + ">"


class UpdateOrganizationRequest:
    """Update organization request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , organization: Organization = None
        , update_mask: protobuf.FieldMask = None
    , **kwargs) -> UpdateOrganizationRequest:
        self._attributes = dict()
        self.organization = organization
        self.update_mask = update_mask

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def organization(self) -> Organization:
        """Organization."""
        return self._attributes["organization"]


    @organization.setter
    def organization(self, value: Organization) -> None:
        _set_attribute(self._attributes, "UpdateOrganizationRequest", "organization", value, Organization, "")


    @property
    def update_mask(self) -> protobuf.FieldMask:
        """Update mask."""
        return self._attributes["update_mask"]


    @update_mask.setter
    def update_mask(self, value: protobuf.FieldMask) -> None:
        _set_attribute(self._attributes, "UpdateOrganizationRequest", "update_mask", value, protobuf.FieldMask, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.UpdateOrganizationRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.UpdateOrganizationRequest:
        """Convert object to proto representation."""
        return management_pb2.UpdateOrganizationRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<UpdateOrganizationRequest object " + repr(self.to_dict()) + ">"


class GetOrganizationRequest:
    """Get organization request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetOrganizationRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetOrganizationRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetOrganizationRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetOrganizationRequest:
        """Convert object to proto representation."""
        return management_pb2.GetOrganizationRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetOrganizationRequest object " + repr(self.to_dict()) + ">"


class BatchGetOrganizationsRequest:
    """Batch get organizations request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , names: List[str] = []
    , **kwargs) -> BatchGetOrganizationsRequest:
        self._attributes = dict()
        self.names = names

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def names(self) -> List[str]:
        """Names."""
        return self._attributes["names"]


    @names.setter
    def names(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "BatchGetOrganizationsRequest", "names", value, List[str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BatchGetOrganizationsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BatchGetOrganizationsRequest:
        """Convert object to proto representation."""
        return management_pb2.BatchGetOrganizationsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchGetOrganizationsRequest object " + repr(self.to_dict()) + ">"


class BatchGetOrganizationsResponse:
    """Batch get organizations response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , organizations: List[Organization] = []
    , **kwargs) -> BatchGetOrganizationsResponse:
        self._attributes = dict()
        self.organizations = organizations

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def organizations(self) -> List[Organization]:
        """Organizations."""
        return self._attributes["organizations"]


    @organizations.setter
    def organizations(self, value: List[Organization]) -> None:
        _set_attribute(self._attributes, "BatchGetOrganizationsResponse", "organizations", value, List[Organization], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BatchGetOrganizationsResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BatchGetOrganizationsResponse:
        """Convert object to proto representation."""
        return management_pb2.BatchGetOrganizationsResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchGetOrganizationsResponse object " + repr(self.to_dict()) + ">"


class DeleteOrganizationRequest:
    """Delete organization request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> DeleteOrganizationRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "DeleteOrganizationRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.DeleteOrganizationRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.DeleteOrganizationRequest:
        """Convert object to proto representation."""
        return management_pb2.DeleteOrganizationRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<DeleteOrganizationRequest object " + repr(self.to_dict()) + ">"


class ListOrganizationsRequest:
    """List organizations request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , page_size: int = 0
        , page_token: str = ""
    , **kwargs) -> ListOrganizationsRequest:
        self._attributes = dict()
        self.page_size = page_size
        self.page_token = page_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def page_size(self) -> int:
        """Page size."""
        return self._attributes["page_size"]


    @page_size.setter
    def page_size(self, value: int) -> None:
        _set_attribute(self._attributes, "ListOrganizationsRequest", "page_size", value, int, "")


    @property
    def page_token(self) -> str:
        """Page token."""
        return self._attributes["page_token"]


    @page_token.setter
    def page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListOrganizationsRequest", "page_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListOrganizationsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListOrganizationsRequest:
        """Convert object to proto representation."""
        return management_pb2.ListOrganizationsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListOrganizationsRequest object " + repr(self.to_dict()) + ">"


class ListOrganizationsResponse:
    """List organizations response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , organizations: List[Organization] = []
        , next_page_token: str = ""
    , **kwargs) -> ListOrganizationsResponse:
        self._attributes = dict()
        self.organizations = organizations
        self.next_page_token = next_page_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def organizations(self) -> List[Organization]:
        """Organizations."""
        return self._attributes["organizations"]


    @organizations.setter
    def organizations(self, value: List[Organization]) -> None:
        _set_attribute(self._attributes, "ListOrganizationsResponse", "organizations", value, List[Organization], "")


    @property
    def next_page_token(self) -> str:
        """Next page token."""
        return self._attributes["next_page_token"]


    @next_page_token.setter
    def next_page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListOrganizationsResponse", "next_page_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListOrganizationsResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListOrganizationsResponse:
        """Convert object to proto representation."""
        return management_pb2.ListOrganizationsResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListOrganizationsResponse object " + repr(self.to_dict()) + ">"


class GetOnboardingRequest:
    """Get onboarding request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetOnboardingRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetOnboardingRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetOnboardingRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetOnboardingRequest:
        """Convert object to proto representation."""
        return management_pb2.GetOnboardingRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetOnboardingRequest object " + repr(self.to_dict()) + ">"


class UpdateOnboardingRequest:
    """Update onboarding request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , onboarding: Onboarding = None
        , update_mask: protobuf.FieldMask = None
    , **kwargs) -> UpdateOnboardingRequest:
        self._attributes = dict()
        self.onboarding = onboarding
        self.update_mask = update_mask

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def onboarding(self) -> Onboarding:
        """Onboarding."""
        return self._attributes["onboarding"]


    @onboarding.setter
    def onboarding(self, value: Onboarding) -> None:
        _set_attribute(self._attributes, "UpdateOnboardingRequest", "onboarding", value, Onboarding, "")


    @property
    def update_mask(self) -> protobuf.FieldMask:
        """Update mask."""
        return self._attributes["update_mask"]


    @update_mask.setter
    def update_mask(self, value: protobuf.FieldMask) -> None:
        _set_attribute(self._attributes, "UpdateOnboardingRequest", "update_mask", value, protobuf.FieldMask, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.UpdateOnboardingRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.UpdateOnboardingRequest:
        """Convert object to proto representation."""
        return management_pb2.UpdateOnboardingRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<UpdateOnboardingRequest object " + repr(self.to_dict()) + ">"


class CreateProjectRequest:
    """Create project request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , project: Project = None
        , project_id: str = ""
    , **kwargs) -> CreateProjectRequest:
        self._attributes = dict()
        self.project = project
        self.project_id = project_id

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def project(self) -> Project:
        """Project."""
        return self._attributes["project"]


    @project.setter
    def project(self, value: Project) -> None:
        _set_attribute(self._attributes, "CreateProjectRequest", "project", value, Project, "")


    @property
    def project_id(self) -> str:
        """Optional user-readable ID to project, which will
 become the last element of the resource name.
 https://aip.dev/133#user-specified-ids"""
        return self._attributes["project_id"]


    @project_id.setter
    def project_id(self, value: str) -> None:
        _set_attribute(self._attributes, "CreateProjectRequest", "project_id", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.CreateProjectRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.CreateProjectRequest:
        """Convert object to proto representation."""
        return management_pb2.CreateProjectRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<CreateProjectRequest object " + repr(self.to_dict()) + ">"


class UpdateProjectRequest:
    """Update project request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , project: Project = None
        , update_mask: protobuf.FieldMask = None
    , **kwargs) -> UpdateProjectRequest:
        self._attributes = dict()
        self.project = project
        self.update_mask = update_mask

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def project(self) -> Project:
        """Project."""
        return self._attributes["project"]


    @project.setter
    def project(self, value: Project) -> None:
        _set_attribute(self._attributes, "UpdateProjectRequest", "project", value, Project, "")


    @property
    def update_mask(self) -> protobuf.FieldMask:
        """Update mask."""
        return self._attributes["update_mask"]


    @update_mask.setter
    def update_mask(self, value: protobuf.FieldMask) -> None:
        _set_attribute(self._attributes, "UpdateProjectRequest", "update_mask", value, protobuf.FieldMask, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.UpdateProjectRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.UpdateProjectRequest:
        """Convert object to proto representation."""
        return management_pb2.UpdateProjectRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<UpdateProjectRequest object " + repr(self.to_dict()) + ">"


class GetProjectRequest:
    """Get project request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetProjectRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetProjectRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetProjectRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetProjectRequest:
        """Convert object to proto representation."""
        return management_pb2.GetProjectRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetProjectRequest object " + repr(self.to_dict()) + ">"


class BatchGetProjectsRequest:
    """Batch get projects request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , names: List[str] = []
    , **kwargs) -> BatchGetProjectsRequest:
        self._attributes = dict()
        self.names = names

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def names(self) -> List[str]:
        """Names."""
        return self._attributes["names"]


    @names.setter
    def names(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "BatchGetProjectsRequest", "names", value, List[str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BatchGetProjectsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BatchGetProjectsRequest:
        """Convert object to proto representation."""
        return management_pb2.BatchGetProjectsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchGetProjectsRequest object " + repr(self.to_dict()) + ">"


class BatchGetProjectsResponse:
    """Batch get projects response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , projects: List[Project] = []
    , **kwargs) -> BatchGetProjectsResponse:
        self._attributes = dict()
        self.projects = projects

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def projects(self) -> List[Project]:
        """Projects."""
        return self._attributes["projects"]


    @projects.setter
    def projects(self, value: List[Project]) -> None:
        _set_attribute(self._attributes, "BatchGetProjectsResponse", "projects", value, List[Project], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BatchGetProjectsResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BatchGetProjectsResponse:
        """Convert object to proto representation."""
        return management_pb2.BatchGetProjectsResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchGetProjectsResponse object " + repr(self.to_dict()) + ">"


class DeleteProjectRequest:
    """Delete project request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , delete_schema: bool = False
    , **kwargs) -> DeleteProjectRequest:
        self._attributes = dict()
        self.name = name
        self.delete_schema = delete_schema

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "DeleteProjectRequest", "name", value, str, "")


    @property
    def delete_schema(self) -> bool:
        """Delete schema."""
        return self._attributes["delete_schema"]


    @delete_schema.setter
    def delete_schema(self, value: bool) -> None:
        _set_attribute(self._attributes, "DeleteProjectRequest", "delete_schema", value, bool, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.DeleteProjectRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.DeleteProjectRequest:
        """Convert object to proto representation."""
        return management_pb2.DeleteProjectRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<DeleteProjectRequest object " + repr(self.to_dict()) + ">"


class ListProjectsRequest:
    """List projects request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , page_size: int = 0
        , page_token: str = ""
        , filters: List[str] = []
        , ignore_filters: List[str] = []
        , start_time: datetime = None
        , end_time: datetime = None
    , **kwargs) -> ListProjectsRequest:
        self._attributes = dict()
        self.parent = parent
        self.page_size = page_size
        self.page_token = page_token
        self.filters = filters
        self.ignore_filters = ignore_filters
        self.start_time = start_time
        self.end_time = end_time

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "ListProjectsRequest", "parent", value, str, "")


    @property
    def page_size(self) -> int:
        """Page size."""
        return self._attributes["page_size"]


    @page_size.setter
    def page_size(self, value: int) -> None:
        _set_attribute(self._attributes, "ListProjectsRequest", "page_size", value, int, "")


    @property
    def page_token(self) -> str:
        """Page token."""
        return self._attributes["page_token"]


    @page_token.setter
    def page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListProjectsRequest", "page_token", value, str, "")


    @property
    def filters(self) -> List[str]:
        """Filters."""
        return self._attributes["filters"]


    @filters.setter
    def filters(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ListProjectsRequest", "filters", value, List[str], "")


    @property
    def ignore_filters(self) -> List[str]:
        """Ignore filters."""
        return self._attributes["ignore_filters"]


    @ignore_filters.setter
    def ignore_filters(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ListProjectsRequest", "ignore_filters", value, List[str], "")


    @property
    def start_time(self) -> datetime:
        """Start time."""
        return self._attributes["start_time"]


    @start_time.setter
    def start_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ListProjectsRequest", "start_time", value, datetime, "")


    @property
    def end_time(self) -> datetime:
        """End time."""
        return self._attributes["end_time"]


    @end_time.setter
    def end_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ListProjectsRequest", "end_time", value, datetime, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListProjectsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListProjectsRequest:
        """Convert object to proto representation."""
        return management_pb2.ListProjectsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListProjectsRequest object " + repr(self.to_dict()) + ">"


class ListProjectsResponse:
    """List projects response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , projects: List[Project] = []
        , next_page_token: str = ""
    , **kwargs) -> ListProjectsResponse:
        self._attributes = dict()
        self.projects = projects
        self.next_page_token = next_page_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def projects(self) -> List[Project]:
        """Projects."""
        return self._attributes["projects"]


    @projects.setter
    def projects(self, value: List[Project]) -> None:
        _set_attribute(self._attributes, "ListProjectsResponse", "projects", value, List[Project], "")


    @property
    def next_page_token(self) -> str:
        """Next page token."""
        return self._attributes["next_page_token"]


    @next_page_token.setter
    def next_page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListProjectsResponse", "next_page_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListProjectsResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListProjectsResponse:
        """Convert object to proto representation."""
        return management_pb2.ListProjectsResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListProjectsResponse object " + repr(self.to_dict()) + ">"


class TestProjectDataStoreRequest:
    """Test project data store request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> TestProjectDataStoreRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "TestProjectDataStoreRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.TestProjectDataStoreRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.TestProjectDataStoreRequest:
        """Convert object to proto representation."""
        return management_pb2.TestProjectDataStoreRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<TestProjectDataStoreRequest object " + repr(self.to_dict()) + ">"


class TestProjectDataStoreResponse:
    """Test project data store response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , success: bool = False
        , error_message: str = ""
    , **kwargs) -> TestProjectDataStoreResponse:
        self._attributes = dict()
        self.success = success
        self.error_message = error_message

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def success(self) -> bool:
        """Success."""
        return self._attributes["success"]


    @success.setter
    def success(self, value: bool) -> None:
        _set_attribute(self._attributes, "TestProjectDataStoreResponse", "success", value, bool, "")


    @property
    def error_message(self) -> str:
        """Error message."""
        return self._attributes["error_message"]


    @error_message.setter
    def error_message(self, value: str) -> None:
        _set_attribute(self._attributes, "TestProjectDataStoreResponse", "error_message", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.TestProjectDataStoreResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.TestProjectDataStoreResponse:
        """Convert object to proto representation."""
        return management_pb2.TestProjectDataStoreResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<TestProjectDataStoreResponse object " + repr(self.to_dict()) + ">"


class TestDataStoreRequest:
    """Test data store request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , data_store: DataStore = None
    , **kwargs) -> TestDataStoreRequest:
        self._attributes = dict()
        self.data_store = data_store

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def data_store(self) -> DataStore:
        """Data store."""
        return self._attributes["data_store"]


    @data_store.setter
    def data_store(self, value: DataStore) -> None:
        _set_attribute(self._attributes, "TestDataStoreRequest", "data_store", value, DataStore, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.TestDataStoreRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.TestDataStoreRequest:
        """Convert object to proto representation."""
        return management_pb2.TestDataStoreRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<TestDataStoreRequest object " + repr(self.to_dict()) + ">"


class TestDataStoreResponse:
    """Test data store response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , success: bool = False
        , error_message: str = ""
    , **kwargs) -> TestDataStoreResponse:
        self._attributes = dict()
        self.success = success
        self.error_message = error_message

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def success(self) -> bool:
        """Success."""
        return self._attributes["success"]


    @success.setter
    def success(self, value: bool) -> None:
        _set_attribute(self._attributes, "TestDataStoreResponse", "success", value, bool, "")


    @property
    def error_message(self) -> str:
        """Error message."""
        return self._attributes["error_message"]


    @error_message.setter
    def error_message(self, value: str) -> None:
        _set_attribute(self._attributes, "TestDataStoreResponse", "error_message", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.TestDataStoreResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.TestDataStoreResponse:
        """Convert object to proto representation."""
        return management_pb2.TestDataStoreResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<TestDataStoreResponse object " + repr(self.to_dict()) + ">"


class GetFeatureSetRequest:
    """Get feature set request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetFeatureSetRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetFeatureSetRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetFeatureSetRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetFeatureSetRequest:
        """Convert object to proto representation."""
        return management_pb2.GetFeatureSetRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetFeatureSetRequest object " + repr(self.to_dict()) + ">"


class CreateChangeRequest:
    """Create change request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , schemas: List[str] = []
        , plan_only: bool = False
        , purge: bool = False
        , update_all: bool = False
        , train_none: bool = False
        , train_all: bool = False
        , profile_none: bool = False
        , message: str = ""
        , trigger: str = ""
        , resource: str = ""
    , **kwargs) -> CreateChangeRequest:
        self._attributes = dict()
        self.parent = parent
        self.schemas = schemas
        self.plan_only = plan_only
        self.purge = purge
        self.update_all = update_all
        self.train_none = train_none
        self.train_all = train_all
        self.profile_none = profile_none
        self.message = message
        self.trigger = trigger
        self.resource = resource

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "CreateChangeRequest", "parent", value, str, "")


    @property
    def schemas(self) -> List[str]:
        """Schemas."""
        return self._attributes["schemas"]


    @schemas.setter
    def schemas(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "CreateChangeRequest", "schemas", value, List[str], "")


    @property
    def plan_only(self) -> bool:
        """Plan only."""
        return self._attributes["plan_only"]


    @plan_only.setter
    def plan_only(self, value: bool) -> None:
        _set_attribute(self._attributes, "CreateChangeRequest", "plan_only", value, bool, "")


    @property
    def purge(self) -> bool:
        """Purge."""
        return self._attributes["purge"]


    @purge.setter
    def purge(self, value: bool) -> None:
        _set_attribute(self._attributes, "CreateChangeRequest", "purge", value, bool, "")


    @property
    def update_all(self) -> bool:
        """Update all."""
        return self._attributes["update_all"]


    @update_all.setter
    def update_all(self, value: bool) -> None:
        _set_attribute(self._attributes, "CreateChangeRequest", "update_all", value, bool, "")


    @property
    def train_none(self) -> bool:
        """Train none."""
        return self._attributes["train_none"]


    @train_none.setter
    def train_none(self, value: bool) -> None:
        _set_attribute(self._attributes, "CreateChangeRequest", "train_none", value, bool, "")


    @property
    def train_all(self) -> bool:
        """Train all."""
        return self._attributes["train_all"]


    @train_all.setter
    def train_all(self, value: bool) -> None:
        _set_attribute(self._attributes, "CreateChangeRequest", "train_all", value, bool, "")


    @property
    def profile_none(self) -> bool:
        """Profile none."""
        return self._attributes["profile_none"]


    @profile_none.setter
    def profile_none(self, value: bool) -> None:
        _set_attribute(self._attributes, "CreateChangeRequest", "profile_none", value, bool, "")


    @property
    def message(self) -> str:
        """Message."""
        return self._attributes["message"]


    @message.setter
    def message(self, value: str) -> None:
        _set_attribute(self._attributes, "CreateChangeRequest", "message", value, str, "")


    @property
    def trigger(self) -> str:
        """Trigger."""
        return self._attributes["trigger"]


    @trigger.setter
    def trigger(self, value: str) -> None:
        _set_attribute(self._attributes, "CreateChangeRequest", "trigger", value, str, "")


    @property
    def resource(self) -> str:
        """Resource."""
        return self._attributes["resource"]


    @resource.setter
    def resource(self, value: str) -> None:
        _set_attribute(self._attributes, "CreateChangeRequest", "resource", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.CreateChangeRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.CreateChangeRequest:
        """Convert object to proto representation."""
        return management_pb2.CreateChangeRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<CreateChangeRequest object " + repr(self.to_dict()) + ">"


class ReRunRequest:
    """Re run request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , message: str = ""
        , trigger: str = ""
    , **kwargs) -> ReRunRequest:
        self._attributes = dict()
        self.name = name
        self.message = message
        self.trigger = trigger

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "ReRunRequest", "name", value, str, "")


    @property
    def message(self) -> str:
        """Message."""
        return self._attributes["message"]


    @message.setter
    def message(self, value: str) -> None:
        _set_attribute(self._attributes, "ReRunRequest", "message", value, str, "")


    @property
    def trigger(self) -> str:
        """Trigger."""
        return self._attributes["trigger"]


    @trigger.setter
    def trigger(self, value: str) -> None:
        _set_attribute(self._attributes, "ReRunRequest", "trigger", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ReRunRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ReRunRequest:
        """Convert object to proto representation."""
        return management_pb2.ReRunRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ReRunRequest object " + repr(self.to_dict()) + ">"


class GetChangeRequest:
    """Get change request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetChangeRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetChangeRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetChangeRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetChangeRequest:
        """Convert object to proto representation."""
        return management_pb2.GetChangeRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetChangeRequest object " + repr(self.to_dict()) + ">"


class GetChangeResponse:
    """Get change response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , plan: List[PlanStep] = []
    , **kwargs) -> GetChangeResponse:
        self._attributes = dict()
        self.name = name
        self.plan = plan

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetChangeResponse", "name", value, str, "")


    @property
    def plan(self) -> List[PlanStep]:
        """Plan."""
        return self._attributes["plan"]


    @plan.setter
    def plan(self, value: List[PlanStep]) -> None:
        _set_attribute(self._attributes, "GetChangeResponse", "plan", value, List[PlanStep], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetChangeResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetChangeResponse:
        """Convert object to proto representation."""
        return management_pb2.GetChangeResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetChangeResponse object " + repr(self.to_dict()) + ">"


class ListChangesRequest:
    """List changes request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , page_token: str = ""
        , page_size: int = 0
        , latest: bool = False
        , filters: List[str] = []
        , ignore_filters: List[str] = []
        , start_time: datetime = None
        , end_time: datetime = None
        , all_projects: bool = False
    , **kwargs) -> ListChangesRequest:
        self._attributes = dict()
        self.parent = parent
        self.page_token = page_token
        self.page_size = page_size
        self.latest = latest
        self.filters = filters
        self.ignore_filters = ignore_filters
        self.start_time = start_time
        self.end_time = end_time
        self.all_projects = all_projects

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "ListChangesRequest", "parent", value, str, "")


    @property
    def page_token(self) -> str:
        """Page token."""
        return self._attributes["page_token"]


    @page_token.setter
    def page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListChangesRequest", "page_token", value, str, "")


    @property
    def page_size(self) -> int:
        """Page size."""
        return self._attributes["page_size"]


    @page_size.setter
    def page_size(self, value: int) -> None:
        _set_attribute(self._attributes, "ListChangesRequest", "page_size", value, int, "")


    @property
    def latest(self) -> bool:
        """Latest."""
        return self._attributes["latest"]


    @latest.setter
    def latest(self, value: bool) -> None:
        _set_attribute(self._attributes, "ListChangesRequest", "latest", value, bool, "")


    @property
    def filters(self) -> List[str]:
        """Filters."""
        return self._attributes["filters"]


    @filters.setter
    def filters(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ListChangesRequest", "filters", value, List[str], "")


    @property
    def ignore_filters(self) -> List[str]:
        """Ignore filters."""
        return self._attributes["ignore_filters"]


    @ignore_filters.setter
    def ignore_filters(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ListChangesRequest", "ignore_filters", value, List[str], "")


    @property
    def start_time(self) -> datetime:
        """Start time."""
        return self._attributes["start_time"]


    @start_time.setter
    def start_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ListChangesRequest", "start_time", value, datetime, "")


    @property
    def end_time(self) -> datetime:
        """End time."""
        return self._attributes["end_time"]


    @end_time.setter
    def end_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ListChangesRequest", "end_time", value, datetime, "")


    @property
    def all_projects(self) -> bool:
        """All projects."""
        return self._attributes["all_projects"]


    @all_projects.setter
    def all_projects(self, value: bool) -> None:
        _set_attribute(self._attributes, "ListChangesRequest", "all_projects", value, bool, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListChangesRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListChangesRequest:
        """Convert object to proto representation."""
        return management_pb2.ListChangesRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListChangesRequest object " + repr(self.to_dict()) + ">"


class ListChangesResponse:
    """List changes response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , plans: List[Change] = []
        , next_page_token: str = ""
    , **kwargs) -> ListChangesResponse:
        self._attributes = dict()
        self.plans = plans
        self.next_page_token = next_page_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def plans(self) -> List[Change]:
        """Plans."""
        return self._attributes["plans"]


    @plans.setter
    def plans(self, value: List[Change]) -> None:
        _set_attribute(self._attributes, "ListChangesResponse", "plans", value, List[Change], "")


    @property
    def next_page_token(self) -> str:
        """Next page token."""
        return self._attributes["next_page_token"]


    @next_page_token.setter
    def next_page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListChangesResponse", "next_page_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListChangesResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListChangesResponse:
        """Convert object to proto representation."""
        return management_pb2.ListChangesResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListChangesResponse object " + repr(self.to_dict()) + ">"


class CancelChangeRequest:
    """Cancel change request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> CancelChangeRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "CancelChangeRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.CancelChangeRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.CancelChangeRequest:
        """Convert object to proto representation."""
        return management_pb2.CancelChangeRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<CancelChangeRequest object " + repr(self.to_dict()) + ">"


class ListFeatureSetsRequest:
    """List feature sets request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , page_token: str = ""
        , page_size: int = 0
        , filters: List[str] = []
        , ignore_filters: List[str] = []
        , start_time: datetime = None
        , end_time: datetime = None
        , all_projects: bool = False
    , **kwargs) -> ListFeatureSetsRequest:
        self._attributes = dict()
        self.parent = parent
        self.page_token = page_token
        self.page_size = page_size
        self.filters = filters
        self.ignore_filters = ignore_filters
        self.start_time = start_time
        self.end_time = end_time
        self.all_projects = all_projects

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "ListFeatureSetsRequest", "parent", value, str, "")


    @property
    def page_token(self) -> str:
        """Page token."""
        return self._attributes["page_token"]


    @page_token.setter
    def page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListFeatureSetsRequest", "page_token", value, str, "")


    @property
    def page_size(self) -> int:
        """Page size."""
        return self._attributes["page_size"]


    @page_size.setter
    def page_size(self, value: int) -> None:
        _set_attribute(self._attributes, "ListFeatureSetsRequest", "page_size", value, int, "")


    @property
    def filters(self) -> List[str]:
        """Filters."""
        return self._attributes["filters"]


    @filters.setter
    def filters(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ListFeatureSetsRequest", "filters", value, List[str], "")


    @property
    def ignore_filters(self) -> List[str]:
        """Ignore filters."""
        return self._attributes["ignore_filters"]


    @ignore_filters.setter
    def ignore_filters(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ListFeatureSetsRequest", "ignore_filters", value, List[str], "")


    @property
    def start_time(self) -> datetime:
        """Start time."""
        return self._attributes["start_time"]


    @start_time.setter
    def start_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ListFeatureSetsRequest", "start_time", value, datetime, "")


    @property
    def end_time(self) -> datetime:
        """End time."""
        return self._attributes["end_time"]


    @end_time.setter
    def end_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ListFeatureSetsRequest", "end_time", value, datetime, "")


    @property
    def all_projects(self) -> bool:
        """All projects."""
        return self._attributes["all_projects"]


    @all_projects.setter
    def all_projects(self, value: bool) -> None:
        _set_attribute(self._attributes, "ListFeatureSetsRequest", "all_projects", value, bool, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListFeatureSetsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListFeatureSetsRequest:
        """Convert object to proto representation."""
        return management_pb2.ListFeatureSetsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListFeatureSetsRequest object " + repr(self.to_dict()) + ">"


class ListFeatureSetsResponse:
    """List feature sets response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , feature_sets: List[FeatureSet] = []
        , next_page_token: str = ""
    , **kwargs) -> ListFeatureSetsResponse:
        self._attributes = dict()
        self.feature_sets = feature_sets
        self.next_page_token = next_page_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def feature_sets(self) -> List[FeatureSet]:
        """Feature sets."""
        return self._attributes["feature_sets"]


    @feature_sets.setter
    def feature_sets(self, value: List[FeatureSet]) -> None:
        _set_attribute(self._attributes, "ListFeatureSetsResponse", "feature_sets", value, List[FeatureSet], "")


    @property
    def next_page_token(self) -> str:
        """Next page token."""
        return self._attributes["next_page_token"]


    @next_page_token.setter
    def next_page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListFeatureSetsResponse", "next_page_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListFeatureSetsResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListFeatureSetsResponse:
        """Convert object to proto representation."""
        return management_pb2.ListFeatureSetsResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListFeatureSetsResponse object " + repr(self.to_dict()) + ">"


class GetEntityFeatureSetsRequest:
    """Get entity feature sets request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , project_name: str = ""
        , entity_id: str = ""
    , **kwargs) -> GetEntityFeatureSetsRequest:
        self._attributes = dict()
        self.project_name = project_name
        self.entity_id = entity_id

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def project_name(self) -> str:
        """Project name."""
        return self._attributes["project_name"]


    @project_name.setter
    def project_name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetEntityFeatureSetsRequest", "project_name", value, str, "")


    @property
    def entity_id(self) -> str:
        """Entity id."""
        return self._attributes["entity_id"]


    @entity_id.setter
    def entity_id(self, value: str) -> None:
        _set_attribute(self._attributes, "GetEntityFeatureSetsRequest", "entity_id", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetEntityFeatureSetsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetEntityFeatureSetsRequest:
        """Convert object to proto representation."""
        return management_pb2.GetEntityFeatureSetsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetEntityFeatureSetsRequest object " + repr(self.to_dict()) + ">"


class GetEntityFeatureSetsResponse:
    """Get entity feature sets response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , feature_sets: List[FeatureSet] = []
    , **kwargs) -> GetEntityFeatureSetsResponse:
        self._attributes = dict()
        self.feature_sets = feature_sets

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def feature_sets(self) -> List[FeatureSet]:
        """Feature sets."""
        return self._attributes["feature_sets"]


    @feature_sets.setter
    def feature_sets(self, value: List[FeatureSet]) -> None:
        _set_attribute(self._attributes, "GetEntityFeatureSetsResponse", "feature_sets", value, List[FeatureSet], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetEntityFeatureSetsResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetEntityFeatureSetsResponse:
        """Convert object to proto representation."""
        return management_pb2.GetEntityFeatureSetsResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetEntityFeatureSetsResponse object " + repr(self.to_dict()) + ">"


class GetEntityRequest:
    """Get entity request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetEntityRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetEntityRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetEntityRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetEntityRequest:
        """Convert object to proto representation."""
        return management_pb2.GetEntityRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetEntityRequest object " + repr(self.to_dict()) + ">"


class ListEntitiesRequest:
    """List entities request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
    , **kwargs) -> ListEntitiesRequest:
        self._attributes = dict()
        self.parent = parent

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Project name."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "ListEntitiesRequest", "parent", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListEntitiesRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListEntitiesRequest:
        """Convert object to proto representation."""
        return management_pb2.ListEntitiesRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListEntitiesRequest object " + repr(self.to_dict()) + ">"


class ListEntitiesResponse:
    """List entities response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , entities: List[Entity] = []
    , **kwargs) -> ListEntitiesResponse:
        self._attributes = dict()
        self.entities = entities

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def entities(self) -> List[Entity]:
        """Entities."""
        return self._attributes["entities"]


    @entities.setter
    def entities(self, value: List[Entity]) -> None:
        _set_attribute(self._attributes, "ListEntitiesResponse", "entities", value, List[Entity], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListEntitiesResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListEntitiesResponse:
        """Convert object to proto representation."""
        return management_pb2.ListEntitiesResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListEntitiesResponse object " + repr(self.to_dict()) + ">"


class BatchGetFeatureSetsRequest:
    """Batch get feature sets request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , names: List[str] = []
    , **kwargs) -> BatchGetFeatureSetsRequest:
        self._attributes = dict()
        self.parent = parent
        self.names = names

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "BatchGetFeatureSetsRequest", "parent", value, str, "")


    @property
    def names(self) -> List[str]:
        """Names."""
        return self._attributes["names"]


    @names.setter
    def names(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "BatchGetFeatureSetsRequest", "names", value, List[str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BatchGetFeatureSetsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BatchGetFeatureSetsRequest:
        """Convert object to proto representation."""
        return management_pb2.BatchGetFeatureSetsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchGetFeatureSetsRequest object " + repr(self.to_dict()) + ">"


class BatchGetFeatureSetsResponse:
    """Batch get feature sets response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , feature_sets: List[FeatureSet] = []
    , **kwargs) -> BatchGetFeatureSetsResponse:
        self._attributes = dict()
        self.feature_sets = feature_sets

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def feature_sets(self) -> List[FeatureSet]:
        """Feature sets."""
        return self._attributes["feature_sets"]


    @feature_sets.setter
    def feature_sets(self, value: List[FeatureSet]) -> None:
        _set_attribute(self._attributes, "BatchGetFeatureSetsResponse", "feature_sets", value, List[FeatureSet], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BatchGetFeatureSetsResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BatchGetFeatureSetsResponse:
        """Convert object to proto representation."""
        return management_pb2.BatchGetFeatureSetsResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchGetFeatureSetsResponse object " + repr(self.to_dict()) + ">"


class DeleteFeatureSetRequest:
    """Delete feature set request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> DeleteFeatureSetRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "DeleteFeatureSetRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.DeleteFeatureSetRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.DeleteFeatureSetRequest:
        """Convert object to proto representation."""
        return management_pb2.DeleteFeatureSetRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<DeleteFeatureSetRequest object " + repr(self.to_dict()) + ">"


class ValidateFeatureSetRequest:
    """Validate feature set request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , environment: str = ""
        , schema: str = ""
    , **kwargs) -> ValidateFeatureSetRequest:
        self._attributes = dict()
        self.environment = environment
        self.schema = schema

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def environment(self) -> str:
        """Environment."""
        return self._attributes["environment"]


    @environment.setter
    def environment(self, value: str) -> None:
        _set_attribute(self._attributes, "ValidateFeatureSetRequest", "environment", value, str, "")


    @property
    def schema(self) -> str:
        """Schema."""
        return self._attributes["schema"]


    @schema.setter
    def schema(self, value: str) -> None:
        _set_attribute(self._attributes, "ValidateFeatureSetRequest", "schema", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ValidateFeatureSetRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ValidateFeatureSetRequest:
        """Convert object to proto representation."""
        return management_pb2.ValidateFeatureSetRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ValidateFeatureSetRequest object " + repr(self.to_dict()) + ">"


class GetFeatureSetDatasetStatsRequest:
    """Get feature set dataset stats request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetFeatureSetDatasetStatsRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetFeatureSetDatasetStatsRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetFeatureSetDatasetStatsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetFeatureSetDatasetStatsRequest:
        """Convert object to proto representation."""
        return management_pb2.GetFeatureSetDatasetStatsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetFeatureSetDatasetStatsRequest object " + repr(self.to_dict()) + ">"


class GetModelDatasetStatsRequest:
    """Get model dataset stats request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetModelDatasetStatsRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetModelDatasetStatsRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetModelDatasetStatsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetModelDatasetStatsRequest:
        """Convert object to proto representation."""
        return management_pb2.GetModelDatasetStatsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetModelDatasetStatsRequest object " + repr(self.to_dict()) + ">"


class GetModelVersionDatasetStatsRequest:
    """Get model version dataset stats request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetModelVersionDatasetStatsRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetModelVersionDatasetStatsRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetModelVersionDatasetStatsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetModelVersionDatasetStatsRequest:
        """Convert object to proto representation."""
        return management_pb2.GetModelVersionDatasetStatsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetModelVersionDatasetStatsRequest object " + repr(self.to_dict()) + ">"


class GetBatchPredictionDatasetStatsRequest:
    """Get batch prediction dataset stats request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetBatchPredictionDatasetStatsRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetBatchPredictionDatasetStatsRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetBatchPredictionDatasetStatsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetBatchPredictionDatasetStatsRequest:
        """Convert object to proto representation."""
        return management_pb2.GetBatchPredictionDatasetStatsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetBatchPredictionDatasetStatsRequest object " + repr(self.to_dict()) + ">"


class GetPredictionStatsRequest:
    """Get prediction stats request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetPredictionStatsRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetPredictionStatsRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetPredictionStatsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetPredictionStatsRequest:
        """Convert object to proto representation."""
        return management_pb2.GetPredictionStatsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetPredictionStatsRequest object " + repr(self.to_dict()) + ">"


class GetFeatureSetStatsRequest:
    """Get feature set stats request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetFeatureSetStatsRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetFeatureSetStatsRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetFeatureSetStatsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetFeatureSetStatsRequest:
        """Convert object to proto representation."""
        return management_pb2.GetFeatureSetStatsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetFeatureSetStatsRequest object " + repr(self.to_dict()) + ">"


class GetModelStatsRequest:
    """Get model stats request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetModelStatsRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetModelStatsRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetModelStatsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetModelStatsRequest:
        """Convert object to proto representation."""
        return management_pb2.GetModelStatsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetModelStatsRequest object " + repr(self.to_dict()) + ">"


class ComputeColumnStatsRequest:
    """Compute column stats request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> ComputeColumnStatsRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "ComputeColumnStatsRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ComputeColumnStatsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ComputeColumnStatsRequest:
        """Convert object to proto representation."""
        return management_pb2.ComputeColumnStatsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ComputeColumnStatsRequest object " + repr(self.to_dict()) + ">"


class GetDataRequest:
    """Get data request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , page_size: int = 0
        , page_token: str = ""
    , **kwargs) -> GetDataRequest:
        self._attributes = dict()
        self.name = name
        self.page_size = page_size
        self.page_token = page_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetDataRequest", "name", value, str, "")


    @property
    def page_size(self) -> int:
        """Number of records to fetch in this iteration."""
        return self._attributes["page_size"]


    @page_size.setter
    def page_size(self, value: int) -> None:
        _set_attribute(self._attributes, "GetDataRequest", "page_size", value, int, "")


    @property
    def page_token(self) -> str:
        """Page Token for getting the next set of records in the iteration."""
        return self._attributes["page_token"]


    @page_token.setter
    def page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "GetDataRequest", "page_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetDataRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetDataRequest:
        """Convert object to proto representation."""
        return management_pb2.GetDataRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetDataRequest object " + repr(self.to_dict()) + ">"


class GetDataResponse:
    """Get data response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , record_count: int = 0
        , next_page_token: str = ""
        , value: List[str] = []
    , **kwargs) -> GetDataResponse:
        self._attributes = dict()
        self.record_count = record_count
        self.next_page_token = next_page_token
        self.value = value

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def record_count(self) -> int:
        """Number of records in this response."""
        return self._attributes["record_count"]


    @record_count.setter
    def record_count(self, value: int) -> None:
        _set_attribute(self._attributes, "GetDataResponse", "record_count", value, int, "")


    @property
    def next_page_token(self) -> str:
        """Page token for iteration."""
        return self._attributes["next_page_token"]


    @next_page_token.setter
    def next_page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "GetDataResponse", "next_page_token", value, str, "")


    @property
    def value(self) -> List[str]:
        """Record set."""
        return self._attributes["value"]


    @value.setter
    def value(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "GetDataResponse", "value", value, List[str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetDataResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetDataResponse:
        """Convert object to proto representation."""
        return management_pb2.GetDataResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetDataResponse object " + repr(self.to_dict()) + ">"


class GetUsageRequest:
    """Get usage request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , start_time: datetime = None
        , end_time: datetime = None
    , **kwargs) -> GetUsageRequest:
        self._attributes = dict()
        self.parent = parent
        self.start_time = start_time
        self.end_time = end_time

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "GetUsageRequest", "parent", value, str, "")


    @property
    def start_time(self) -> datetime:
        """Start time."""
        return self._attributes["start_time"]


    @start_time.setter
    def start_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "GetUsageRequest", "start_time", value, datetime, "")


    @property
    def end_time(self) -> datetime:
        """End time."""
        return self._attributes["end_time"]


    @end_time.setter
    def end_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "GetUsageRequest", "end_time", value, datetime, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetUsageRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetUsageRequest:
        """Convert object to proto representation."""
        return management_pb2.GetUsageRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetUsageRequest object " + repr(self.to_dict()) + ">"


class GetUsageResponse:
    """Get usage response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , credits_per_day: List[CreditUsageRecord] = []
    , **kwargs) -> GetUsageResponse:
        self._attributes = dict()
        self.credits_per_day = credits_per_day

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def credits_per_day(self) -> List[CreditUsageRecord]:
        """Credits per day."""
        return self._attributes["credits_per_day"]


    @credits_per_day.setter
    def credits_per_day(self, value: List[CreditUsageRecord]) -> None:
        _set_attribute(self._attributes, "GetUsageResponse", "credits_per_day", value, List[CreditUsageRecord], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetUsageResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetUsageResponse:
        """Convert object to proto representation."""
        return management_pb2.GetUsageResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetUsageResponse object " + repr(self.to_dict()) + ">"


class ListPricesRequest:
    """List prices request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
    , **kwargs) -> ListPricesRequest:
        self._attributes = dict()
        self.parent = parent

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "ListPricesRequest", "parent", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListPricesRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListPricesRequest:
        """Convert object to proto representation."""
        return management_pb2.ListPricesRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListPricesRequest object " + repr(self.to_dict()) + ">"


class ListPricesResponse:
    """List prices response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , prices: List[Price] = []
    , **kwargs) -> ListPricesResponse:
        self._attributes = dict()
        self.prices = prices

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def prices(self) -> List[Price]:
        """Prices."""
        return self._attributes["prices"]


    @prices.setter
    def prices(self, value: List[Price]) -> None:
        _set_attribute(self._attributes, "ListPricesResponse", "prices", value, List[Price], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListPricesResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListPricesResponse:
        """Convert object to proto representation."""
        return management_pb2.ListPricesResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListPricesResponse object " + repr(self.to_dict()) + ">"


class ListInvoicesRequest:
    """List invoices request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , page_size: int = 0
        , page_token: str = ""
    , **kwargs) -> ListInvoicesRequest:
        self._attributes = dict()
        self.parent = parent
        self.page_size = page_size
        self.page_token = page_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "ListInvoicesRequest", "parent", value, str, "")


    @property
    def page_size(self) -> int:
        """Page size."""
        return self._attributes["page_size"]


    @page_size.setter
    def page_size(self, value: int) -> None:
        _set_attribute(self._attributes, "ListInvoicesRequest", "page_size", value, int, "")


    @property
    def page_token(self) -> str:
        """Page token."""
        return self._attributes["page_token"]


    @page_token.setter
    def page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListInvoicesRequest", "page_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListInvoicesRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListInvoicesRequest:
        """Convert object to proto representation."""
        return management_pb2.ListInvoicesRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListInvoicesRequest object " + repr(self.to_dict()) + ">"


class ListInvoicesResponse:
    """List invoices response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , invoices: List[Invoice] = []
        , next_page_token: str = ""
    , **kwargs) -> ListInvoicesResponse:
        self._attributes = dict()
        self.invoices = invoices
        self.next_page_token = next_page_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def invoices(self) -> List[Invoice]:
        """Invoices."""
        return self._attributes["invoices"]


    @invoices.setter
    def invoices(self, value: List[Invoice]) -> None:
        _set_attribute(self._attributes, "ListInvoicesResponse", "invoices", value, List[Invoice], "")


    @property
    def next_page_token(self) -> str:
        """Next page token."""
        return self._attributes["next_page_token"]


    @next_page_token.setter
    def next_page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListInvoicesResponse", "next_page_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListInvoicesResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListInvoicesResponse:
        """Convert object to proto representation."""
        return management_pb2.ListInvoicesResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListInvoicesResponse object " + repr(self.to_dict()) + ">"


class GetPriceRequest:
    """Get price request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetPriceRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetPriceRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetPriceRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetPriceRequest:
        """Convert object to proto representation."""
        return management_pb2.GetPriceRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetPriceRequest object " + repr(self.to_dict()) + ">"


class GetPaymentMethodRequest:
    """Get payment method request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetPaymentMethodRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetPaymentMethodRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetPaymentMethodRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetPaymentMethodRequest:
        """Convert object to proto representation."""
        return management_pb2.GetPaymentMethodRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetPaymentMethodRequest object " + repr(self.to_dict()) + ">"


class GetUpcomingInvoiceRequest:
    """Get upcoming invoice request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetUpcomingInvoiceRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetUpcomingInvoiceRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetUpcomingInvoiceRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetUpcomingInvoiceRequest:
        """Convert object to proto representation."""
        return management_pb2.GetUpcomingInvoiceRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetUpcomingInvoiceRequest object " + repr(self.to_dict()) + ">"


class GetSubscriptionRequest:
    """Get subscription request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetSubscriptionRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetSubscriptionRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetSubscriptionRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetSubscriptionRequest:
        """Convert object to proto representation."""
        return management_pb2.GetSubscriptionRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetSubscriptionRequest object " + repr(self.to_dict()) + ">"


class GetBillingAccountRequest:
    """Get billing account request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetBillingAccountRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetBillingAccountRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetBillingAccountRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetBillingAccountRequest:
        """Convert object to proto representation."""
        return management_pb2.GetBillingAccountRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetBillingAccountRequest object " + repr(self.to_dict()) + ">"


class UpdateBillingAccountRequest:
    """Update billing account request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , billing_account: BillingAccount = None
        , update_mask: protobuf.FieldMask = None
    , **kwargs) -> UpdateBillingAccountRequest:
        self._attributes = dict()
        self.billing_account = billing_account
        self.update_mask = update_mask

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def billing_account(self) -> BillingAccount:
        """Billing account."""
        return self._attributes["billing_account"]


    @billing_account.setter
    def billing_account(self, value: BillingAccount) -> None:
        _set_attribute(self._attributes, "UpdateBillingAccountRequest", "billing_account", value, BillingAccount, "")


    @property
    def update_mask(self) -> protobuf.FieldMask:
        """Update mask."""
        return self._attributes["update_mask"]


    @update_mask.setter
    def update_mask(self, value: protobuf.FieldMask) -> None:
        _set_attribute(self._attributes, "UpdateBillingAccountRequest", "update_mask", value, protobuf.FieldMask, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.UpdateBillingAccountRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.UpdateBillingAccountRequest:
        """Convert object to proto representation."""
        return management_pb2.UpdateBillingAccountRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<UpdateBillingAccountRequest object " + repr(self.to_dict()) + ">"


class UpdateSubscriptionRequest:
    """Update subscription request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , subscription: Subscription = None
        , update_mask: protobuf.FieldMask = None
    , **kwargs) -> UpdateSubscriptionRequest:
        self._attributes = dict()
        self.subscription = subscription
        self.update_mask = update_mask

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def subscription(self) -> Subscription:
        """Subscription."""
        return self._attributes["subscription"]


    @subscription.setter
    def subscription(self, value: Subscription) -> None:
        _set_attribute(self._attributes, "UpdateSubscriptionRequest", "subscription", value, Subscription, "")


    @property
    def update_mask(self) -> protobuf.FieldMask:
        """Update mask."""
        return self._attributes["update_mask"]


    @update_mask.setter
    def update_mask(self, value: protobuf.FieldMask) -> None:
        _set_attribute(self._attributes, "UpdateSubscriptionRequest", "update_mask", value, protobuf.FieldMask, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.UpdateSubscriptionRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.UpdateSubscriptionRequest:
        """Convert object to proto representation."""
        return management_pb2.UpdateSubscriptionRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<UpdateSubscriptionRequest object " + repr(self.to_dict()) + ">"


class CreateFeatureSetCSVSignedURLRequest:
    """Create feature set c s v signed u r l request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , file_name: str = ""
    , **kwargs) -> CreateFeatureSetCSVSignedURLRequest:
        self._attributes = dict()
        self.parent = parent
        self.file_name = file_name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "CreateFeatureSetCSVSignedURLRequest", "parent", value, str, "")


    @property
    def file_name(self) -> str:
        """File name."""
        return self._attributes["file_name"]


    @file_name.setter
    def file_name(self, value: str) -> None:
        _set_attribute(self._attributes, "CreateFeatureSetCSVSignedURLRequest", "file_name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.CreateFeatureSetCSVSignedURLRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.CreateFeatureSetCSVSignedURLRequest:
        """Convert object to proto representation."""
        return management_pb2.CreateFeatureSetCSVSignedURLRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<CreateFeatureSetCSVSignedURLRequest object " + repr(self.to_dict()) + ">"


class CreateFeatureSetCSVSignedURLResponse:
    """Create feature set c s v signed u r l response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , signed_url: str = ""
        , bucket_path: str = ""
    , **kwargs) -> CreateFeatureSetCSVSignedURLResponse:
        self._attributes = dict()
        self.signed_url = signed_url
        self.bucket_path = bucket_path

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def signed_url(self) -> str:
        """Signed url."""
        return self._attributes["signed_url"]


    @signed_url.setter
    def signed_url(self, value: str) -> None:
        _set_attribute(self._attributes, "CreateFeatureSetCSVSignedURLResponse", "signed_url", value, str, "")


    @property
    def bucket_path(self) -> str:
        """Bucket path."""
        return self._attributes["bucket_path"]


    @bucket_path.setter
    def bucket_path(self, value: str) -> None:
        _set_attribute(self._attributes, "CreateFeatureSetCSVSignedURLResponse", "bucket_path", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.CreateFeatureSetCSVSignedURLResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.CreateFeatureSetCSVSignedURLResponse:
        """Convert object to proto representation."""
        return management_pb2.CreateFeatureSetCSVSignedURLResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<CreateFeatureSetCSVSignedURLResponse object " + repr(self.to_dict()) + ">"


class PromoteModelVersionRequest:
    """Promote model version request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> PromoteModelVersionRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "PromoteModelVersionRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.PromoteModelVersionRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.PromoteModelVersionRequest:
        """Convert object to proto representation."""
        return management_pb2.PromoteModelVersionRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<PromoteModelVersionRequest object " + repr(self.to_dict()) + ">"


class ListPromotionsRequest:
    """List promotions request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , page_token: str = ""
        , page_size: int = 0
        , active: bool = False
        , filters: List[str] = []
        , ignore_filters: List[str] = []
        , start_time: datetime = None
        , end_time: datetime = None
        , all_projects: bool = False
    , **kwargs) -> ListPromotionsRequest:
        self._attributes = dict()
        self.parent = parent
        self.page_token = page_token
        self.page_size = page_size
        self.active = active
        self.filters = filters
        self.ignore_filters = ignore_filters
        self.start_time = start_time
        self.end_time = end_time
        self.all_projects = all_projects

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "ListPromotionsRequest", "parent", value, str, "")


    @property
    def page_token(self) -> str:
        """Page token."""
        return self._attributes["page_token"]


    @page_token.setter
    def page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListPromotionsRequest", "page_token", value, str, "")


    @property
    def page_size(self) -> int:
        """Page size."""
        return self._attributes["page_size"]


    @page_size.setter
    def page_size(self, value: int) -> None:
        _set_attribute(self._attributes, "ListPromotionsRequest", "page_size", value, int, "")


    @property
    def active(self) -> bool:
        """Active."""
        return self._attributes["active"]


    @active.setter
    def active(self, value: bool) -> None:
        _set_attribute(self._attributes, "ListPromotionsRequest", "active", value, bool, "")


    @property
    def filters(self) -> List[str]:
        """Filters."""
        return self._attributes["filters"]


    @filters.setter
    def filters(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ListPromotionsRequest", "filters", value, List[str], "")


    @property
    def ignore_filters(self) -> List[str]:
        """Ignore filters."""
        return self._attributes["ignore_filters"]


    @ignore_filters.setter
    def ignore_filters(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ListPromotionsRequest", "ignore_filters", value, List[str], "")


    @property
    def start_time(self) -> datetime:
        """Start time."""
        return self._attributes["start_time"]


    @start_time.setter
    def start_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ListPromotionsRequest", "start_time", value, datetime, "")


    @property
    def end_time(self) -> datetime:
        """End time."""
        return self._attributes["end_time"]


    @end_time.setter
    def end_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ListPromotionsRequest", "end_time", value, datetime, "")


    @property
    def all_projects(self) -> bool:
        """All projects."""
        return self._attributes["all_projects"]


    @all_projects.setter
    def all_projects(self, value: bool) -> None:
        _set_attribute(self._attributes, "ListPromotionsRequest", "all_projects", value, bool, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListPromotionsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListPromotionsRequest:
        """Convert object to proto representation."""
        return management_pb2.ListPromotionsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListPromotionsRequest object " + repr(self.to_dict()) + ">"


class ListPromotionsResponse:
    """List promotions response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , promotions: List[Promotion] = []
        , next_page_token: str = ""
    , **kwargs) -> ListPromotionsResponse:
        self._attributes = dict()
        self.promotions = promotions
        self.next_page_token = next_page_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def promotions(self) -> List[Promotion]:
        """Promotions."""
        return self._attributes["promotions"]


    @promotions.setter
    def promotions(self, value: List[Promotion]) -> None:
        _set_attribute(self._attributes, "ListPromotionsResponse", "promotions", value, List[Promotion], "")


    @property
    def next_page_token(self) -> str:
        """Next page token."""
        return self._attributes["next_page_token"]


    @next_page_token.setter
    def next_page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListPromotionsResponse", "next_page_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListPromotionsResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListPromotionsResponse:
        """Convert object to proto representation."""
        return management_pb2.ListPromotionsResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListPromotionsResponse object " + repr(self.to_dict()) + ">"


class GetPromotionRequest:
    """Get promotion request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetPromotionRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetPromotionRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetPromotionRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetPromotionRequest:
        """Convert object to proto representation."""
        return management_pb2.GetPromotionRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetPromotionRequest object " + repr(self.to_dict()) + ">"


class BatchGetPromotionsRequest:
    """Batch get promotions request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , names: List[str] = []
    , **kwargs) -> BatchGetPromotionsRequest:
        self._attributes = dict()
        self.parent = parent
        self.names = names

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "BatchGetPromotionsRequest", "parent", value, str, "")


    @property
    def names(self) -> List[str]:
        """Names."""
        return self._attributes["names"]


    @names.setter
    def names(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "BatchGetPromotionsRequest", "names", value, List[str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BatchGetPromotionsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BatchGetPromotionsRequest:
        """Convert object to proto representation."""
        return management_pb2.BatchGetPromotionsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchGetPromotionsRequest object " + repr(self.to_dict()) + ">"


class BatchGetPromotionsResponse:
    """Batch get promotions response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , promotions: List[Promotion] = []
    , **kwargs) -> BatchGetPromotionsResponse:
        self._attributes = dict()
        self.promotions = promotions

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def promotions(self) -> List[Promotion]:
        """Promotions."""
        return self._attributes["promotions"]


    @promotions.setter
    def promotions(self, value: List[Promotion]) -> None:
        _set_attribute(self._attributes, "BatchGetPromotionsResponse", "promotions", value, List[Promotion], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BatchGetPromotionsResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BatchGetPromotionsResponse:
        """Convert object to proto representation."""
        return management_pb2.BatchGetPromotionsResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchGetPromotionsResponse object " + repr(self.to_dict()) + ">"


class ListEventsRequest:
    """currently support filters are:
  - subject (e.g. subject:users/system)
  - event (e.g. featureSet:CREATED)
  - severity (e.g. severity:INFO, severity:CRITICAL)
 NOTE: google endpoints do not support maps, so using a list of string
 delimited with a colon"""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , filters: List[str] = []
        , ignore_filters: List[str] = []
        , start_time: datetime = None
        , end_time: datetime = None
        , page_token: str = ""
        , page_size: int = 0
        , all_projects: bool = False
    , **kwargs) -> ListEventsRequest:
        self._attributes = dict()
        self.parent = parent
        self.filters = filters
        self.ignore_filters = ignore_filters
        self.start_time = start_time
        self.end_time = end_time
        self.page_token = page_token
        self.page_size = page_size
        self.all_projects = all_projects

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "ListEventsRequest", "parent", value, str, "")


    @property
    def filters(self) -> List[str]:
        """Filters."""
        return self._attributes["filters"]


    @filters.setter
    def filters(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ListEventsRequest", "filters", value, List[str], "")


    @property
    def ignore_filters(self) -> List[str]:
        """Ignore filters."""
        return self._attributes["ignore_filters"]


    @ignore_filters.setter
    def ignore_filters(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ListEventsRequest", "ignore_filters", value, List[str], "")


    @property
    def start_time(self) -> datetime:
        """Start time."""
        return self._attributes["start_time"]


    @start_time.setter
    def start_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ListEventsRequest", "start_time", value, datetime, "")


    @property
    def end_time(self) -> datetime:
        """End time."""
        return self._attributes["end_time"]


    @end_time.setter
    def end_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ListEventsRequest", "end_time", value, datetime, "")


    @property
    def page_token(self) -> str:
        """Page token."""
        return self._attributes["page_token"]


    @page_token.setter
    def page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListEventsRequest", "page_token", value, str, "")


    @property
    def page_size(self) -> int:
        """Page size."""
        return self._attributes["page_size"]


    @page_size.setter
    def page_size(self, value: int) -> None:
        _set_attribute(self._attributes, "ListEventsRequest", "page_size", value, int, "")


    @property
    def all_projects(self) -> bool:
        """All projects."""
        return self._attributes["all_projects"]


    @all_projects.setter
    def all_projects(self, value: bool) -> None:
        _set_attribute(self._attributes, "ListEventsRequest", "all_projects", value, bool, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListEventsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListEventsRequest:
        """Convert object to proto representation."""
        return management_pb2.ListEventsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListEventsRequest object " + repr(self.to_dict()) + ">"


class ListEventsResponse:
    """List events response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , events: List[Event] = []
        , next_page_token: str = ""
    , **kwargs) -> ListEventsResponse:
        self._attributes = dict()
        self.events = events
        self.next_page_token = next_page_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def events(self) -> List[Event]:
        """Events."""
        return self._attributes["events"]


    @events.setter
    def events(self, value: List[Event]) -> None:
        _set_attribute(self._attributes, "ListEventsResponse", "events", value, List[Event], "")


    @property
    def next_page_token(self) -> str:
        """Next page token."""
        return self._attributes["next_page_token"]


    @next_page_token.setter
    def next_page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListEventsResponse", "next_page_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListEventsResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListEventsResponse:
        """Convert object to proto representation."""
        return management_pb2.ListEventsResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListEventsResponse object " + repr(self.to_dict()) + ">"


class GetEventRequest:
    """Get event request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetEventRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetEventRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetEventRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetEventRequest:
        """Convert object to proto representation."""
        return management_pb2.GetEventRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetEventRequest object " + repr(self.to_dict()) + ">"


class BatchGetEventsRequest:
    """Batch get events request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , names: List[str] = []
    , **kwargs) -> BatchGetEventsRequest:
        self._attributes = dict()
        self.parent = parent
        self.names = names

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "BatchGetEventsRequest", "parent", value, str, "")


    @property
    def names(self) -> List[str]:
        """Names."""
        return self._attributes["names"]


    @names.setter
    def names(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "BatchGetEventsRequest", "names", value, List[str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BatchGetEventsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BatchGetEventsRequest:
        """Convert object to proto representation."""
        return management_pb2.BatchGetEventsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchGetEventsRequest object " + repr(self.to_dict()) + ">"


class BatchGetEventsResponse:
    """Batch get events response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , events: List[Event] = []
    , **kwargs) -> BatchGetEventsResponse:
        self._attributes = dict()
        self.events = events

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def events(self) -> List[Event]:
        """Events."""
        return self._attributes["events"]


    @events.setter
    def events(self, value: List[Event]) -> None:
        _set_attribute(self._attributes, "BatchGetEventsResponse", "events", value, List[Event], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BatchGetEventsResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BatchGetEventsResponse:
        """Convert object to proto representation."""
        return management_pb2.BatchGetEventsResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchGetEventsResponse object " + repr(self.to_dict()) + ">"


class GetInferredSchemaRequest:
    """Get inferred schema request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , project: str = ""
        , file: str = ""
        , query: str = ""
        , table: str = ""
        , sample_row_count: int = 0
    , **kwargs) -> GetInferredSchemaRequest:
        self._attributes = dict()
        self.project = project
        self.file = file
        self.query = query
        self.table = table
        self.sample_row_count = sample_row_count

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def project(self) -> str:
        """Project."""
        return self._attributes["project"]


    @project.setter
    def project(self, value: str) -> None:
        _set_attribute(self._attributes, "GetInferredSchemaRequest", "project", value, str, "")


    @property
    def file(self) -> str:
        """For inferring schema from a file (Currently only CSV is supported)"""
        return self._attributes["file"]


    @file.setter
    def file(self, value: str) -> None:
        _set_attribute(self._attributes, "GetInferredSchemaRequest", "file", value, str, "")


    @property
    def query(self) -> str:
        """Query."""
        return self._attributes["query"]


    @query.setter
    def query(self, value: str) -> None:
        _set_attribute(self._attributes, "GetInferredSchemaRequest", "query", value, str, "")


    @property
    def table(self) -> str:
        """Table."""
        return self._attributes["table"]


    @table.setter
    def table(self, value: str) -> None:
        _set_attribute(self._attributes, "GetInferredSchemaRequest", "table", value, str, "")


    @property
    def sample_row_count(self) -> int:
        """Sample row count."""
        return self._attributes["sample_row_count"]


    @sample_row_count.setter
    def sample_row_count(self, value: int) -> None:
        _set_attribute(self._attributes, "GetInferredSchemaRequest", "sample_row_count", value, int, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetInferredSchemaRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetInferredSchemaRequest:
        """Convert object to proto representation."""
        return management_pb2.GetInferredSchemaRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetInferredSchemaRequest object " + repr(self.to_dict()) + ">"


class GetInferredSchemaResponse:
    """Get inferred schema response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , columns: List[ColumnConfig] = []
        , record_count: int = 0
        , values: List[str] = []
    , **kwargs) -> GetInferredSchemaResponse:
        self._attributes = dict()
        self.columns = columns
        self.record_count = record_count
        self.values = values

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def columns(self) -> List[ColumnConfig]:
        """Columns."""
        return self._attributes["columns"]


    @columns.setter
    def columns(self, value: List[ColumnConfig]) -> None:
        _set_attribute(self._attributes, "GetInferredSchemaResponse", "columns", value, List[ColumnConfig], "")


    @property
    def record_count(self) -> int:
        """Record count."""
        return self._attributes["record_count"]


    @record_count.setter
    def record_count(self, value: int) -> None:
        _set_attribute(self._attributes, "GetInferredSchemaResponse", "record_count", value, int, "")


    @property
    def values(self) -> List[str]:
        """Values."""
        return self._attributes["values"]


    @values.setter
    def values(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "GetInferredSchemaResponse", "values", value, List[str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetInferredSchemaResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetInferredSchemaResponse:
        """Convert object to proto representation."""
        return management_pb2.GetInferredSchemaResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetInferredSchemaResponse object " + repr(self.to_dict()) + ">"


class GetModelRequest:
    """Get model request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetModelRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetModelRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetModelRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetModelRequest:
        """Convert object to proto representation."""
        return management_pb2.GetModelRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetModelRequest object " + repr(self.to_dict()) + ">"


class BatchGetModelsRequest:
    """Batch get models request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , names: List[str] = []
    , **kwargs) -> BatchGetModelsRequest:
        self._attributes = dict()
        self.parent = parent
        self.names = names

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "BatchGetModelsRequest", "parent", value, str, "")


    @property
    def names(self) -> List[str]:
        """Names."""
        return self._attributes["names"]


    @names.setter
    def names(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "BatchGetModelsRequest", "names", value, List[str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BatchGetModelsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BatchGetModelsRequest:
        """Convert object to proto representation."""
        return management_pb2.BatchGetModelsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchGetModelsRequest object " + repr(self.to_dict()) + ">"


class BatchGetModelsResponse:
    """Batch get models response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , models: List[Model] = []
    , **kwargs) -> BatchGetModelsResponse:
        self._attributes = dict()
        self.models = models

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def models(self) -> List[Model]:
        """Models."""
        return self._attributes["models"]


    @models.setter
    def models(self, value: List[Model]) -> None:
        _set_attribute(self._attributes, "BatchGetModelsResponse", "models", value, List[Model], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BatchGetModelsResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BatchGetModelsResponse:
        """Convert object to proto representation."""
        return management_pb2.BatchGetModelsResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchGetModelsResponse object " + repr(self.to_dict()) + ">"


class ListModelsRequest:
    """List models request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , page_size: int = 0
        , page_token: str = ""
        , show_deleted: bool = False
        , latest: bool = False
        , filters: List[str] = []
        , ignore_filters: List[str] = []
        , start_time: datetime = None
        , end_time: datetime = None
        , all_projects: bool = False
    , **kwargs) -> ListModelsRequest:
        self._attributes = dict()
        self.parent = parent
        self.page_size = page_size
        self.page_token = page_token
        self.show_deleted = show_deleted
        self.latest = latest
        self.filters = filters
        self.ignore_filters = ignore_filters
        self.start_time = start_time
        self.end_time = end_time
        self.all_projects = all_projects

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "ListModelsRequest", "parent", value, str, "")


    @property
    def page_size(self) -> int:
        """Page size."""
        return self._attributes["page_size"]


    @page_size.setter
    def page_size(self, value: int) -> None:
        _set_attribute(self._attributes, "ListModelsRequest", "page_size", value, int, "")


    @property
    def page_token(self) -> str:
        """Page token."""
        return self._attributes["page_token"]


    @page_token.setter
    def page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListModelsRequest", "page_token", value, str, "")


    @property
    def show_deleted(self) -> bool:
        """Show deleted."""
        return self._attributes["show_deleted"]


    @show_deleted.setter
    def show_deleted(self, value: bool) -> None:
        _set_attribute(self._attributes, "ListModelsRequest", "show_deleted", value, bool, "")


    @property
    def latest(self) -> bool:
        """Latest."""
        return self._attributes["latest"]


    @latest.setter
    def latest(self, value: bool) -> None:
        _set_attribute(self._attributes, "ListModelsRequest", "latest", value, bool, "")


    @property
    def filters(self) -> List[str]:
        """Filters."""
        return self._attributes["filters"]


    @filters.setter
    def filters(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ListModelsRequest", "filters", value, List[str], "")


    @property
    def ignore_filters(self) -> List[str]:
        """Ignore filters."""
        return self._attributes["ignore_filters"]


    @ignore_filters.setter
    def ignore_filters(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ListModelsRequest", "ignore_filters", value, List[str], "")


    @property
    def start_time(self) -> datetime:
        """Start time."""
        return self._attributes["start_time"]


    @start_time.setter
    def start_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ListModelsRequest", "start_time", value, datetime, "")


    @property
    def end_time(self) -> datetime:
        """End time."""
        return self._attributes["end_time"]


    @end_time.setter
    def end_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ListModelsRequest", "end_time", value, datetime, "")


    @property
    def all_projects(self) -> bool:
        """All projects."""
        return self._attributes["all_projects"]


    @all_projects.setter
    def all_projects(self, value: bool) -> None:
        _set_attribute(self._attributes, "ListModelsRequest", "all_projects", value, bool, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListModelsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListModelsRequest:
        """Convert object to proto representation."""
        return management_pb2.ListModelsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListModelsRequest object " + repr(self.to_dict()) + ">"


class ListModelsResponse:
    """List models response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , models: List[Model] = []
        , next_page_token: str = ""
    , **kwargs) -> ListModelsResponse:
        self._attributes = dict()
        self.models = models
        self.next_page_token = next_page_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def models(self) -> List[Model]:
        """Models."""
        return self._attributes["models"]


    @models.setter
    def models(self, value: List[Model]) -> None:
        _set_attribute(self._attributes, "ListModelsResponse", "models", value, List[Model], "")


    @property
    def next_page_token(self) -> str:
        """Next page token."""
        return self._attributes["next_page_token"]


    @next_page_token.setter
    def next_page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListModelsResponse", "next_page_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListModelsResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListModelsResponse:
        """Convert object to proto representation."""
        return management_pb2.ListModelsResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListModelsResponse object " + repr(self.to_dict()) + ">"


class DeleteModelRequest:
    """Delete model request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> DeleteModelRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "DeleteModelRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.DeleteModelRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.DeleteModelRequest:
        """Convert object to proto representation."""
        return management_pb2.DeleteModelRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<DeleteModelRequest object " + repr(self.to_dict()) + ">"


class ValidateModelRequest:
    """Validate model request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , environment: str = ""
        , schema: str = ""
    , **kwargs) -> ValidateModelRequest:
        self._attributes = dict()
        self.environment = environment
        self.schema = schema

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def environment(self) -> str:
        """Environment."""
        return self._attributes["environment"]


    @environment.setter
    def environment(self, value: str) -> None:
        _set_attribute(self._attributes, "ValidateModelRequest", "environment", value, str, "")


    @property
    def schema(self) -> str:
        """Schema."""
        return self._attributes["schema"]


    @schema.setter
    def schema(self, value: str) -> None:
        _set_attribute(self._attributes, "ValidateModelRequest", "schema", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ValidateModelRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ValidateModelRequest:
        """Convert object to proto representation."""
        return management_pb2.ValidateModelRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ValidateModelRequest object " + repr(self.to_dict()) + ">"


class GetModelVersionRequest:
    """MODEL VERSIONS"""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetModelVersionRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetModelVersionRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetModelVersionRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetModelVersionRequest:
        """Convert object to proto representation."""
        return management_pb2.GetModelVersionRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetModelVersionRequest object " + repr(self.to_dict()) + ">"


class GetModelVersionQueryRequest:
    """Get model version query request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetModelVersionQueryRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetModelVersionQueryRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetModelVersionQueryRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetModelVersionQueryRequest:
        """Convert object to proto representation."""
        return management_pb2.GetModelVersionQueryRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetModelVersionQueryRequest object " + repr(self.to_dict()) + ">"


class GetModelVersionQueryResponse:
    """Get model version query response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , query: Query = None
    , **kwargs) -> GetModelVersionQueryResponse:
        self._attributes = dict()
        self.query = query

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def query(self) -> Query:
        """returning a response message and not just a query message
 because we will likely be passing back documentation as well"""
        return self._attributes["query"]


    @query.setter
    def query(self, value: Query) -> None:
        _set_attribute(self._attributes, "GetModelVersionQueryResponse", "query", value, Query, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetModelVersionQueryResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetModelVersionQueryResponse:
        """Convert object to proto representation."""
        return management_pb2.GetModelVersionQueryResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetModelVersionQueryResponse object " + repr(self.to_dict()) + ">"


class BatchGetModelVersionsRequest:
    """Batch get model versions request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , names: List[str] = []
    , **kwargs) -> BatchGetModelVersionsRequest:
        self._attributes = dict()
        self.parent = parent
        self.names = names

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "BatchGetModelVersionsRequest", "parent", value, str, "")


    @property
    def names(self) -> List[str]:
        """Names."""
        return self._attributes["names"]


    @names.setter
    def names(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "BatchGetModelVersionsRequest", "names", value, List[str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BatchGetModelVersionsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BatchGetModelVersionsRequest:
        """Convert object to proto representation."""
        return management_pb2.BatchGetModelVersionsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchGetModelVersionsRequest object " + repr(self.to_dict()) + ">"


class BatchGetModelVersionsResponse:
    """Batch get model versions response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , model_versions: List[ModelVersion] = []
    , **kwargs) -> BatchGetModelVersionsResponse:
        self._attributes = dict()
        self.model_versions = model_versions

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def model_versions(self) -> List[ModelVersion]:
        """Model versions."""
        return self._attributes["model_versions"]


    @model_versions.setter
    def model_versions(self, value: List[ModelVersion]) -> None:
        _set_attribute(self._attributes, "BatchGetModelVersionsResponse", "model_versions", value, List[ModelVersion], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BatchGetModelVersionsResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BatchGetModelVersionsResponse:
        """Convert object to proto representation."""
        return management_pb2.BatchGetModelVersionsResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchGetModelVersionsResponse object " + repr(self.to_dict()) + ">"


class ListModelVersionsRequest:
    """List model versions request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , page_size: int = 0
        , page_token: str = ""
        , latest: bool = False
        , filters: List[str] = []
        , ignore_filters: List[str] = []
        , start_time: datetime = None
        , end_time: datetime = None
        , all_projects: bool = False
    , **kwargs) -> ListModelVersionsRequest:
        self._attributes = dict()
        self.parent = parent
        self.page_size = page_size
        self.page_token = page_token
        self.latest = latest
        self.filters = filters
        self.ignore_filters = ignore_filters
        self.start_time = start_time
        self.end_time = end_time
        self.all_projects = all_projects

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "ListModelVersionsRequest", "parent", value, str, "")


    @property
    def page_size(self) -> int:
        """The maximum number of items to return."""
        return self._attributes["page_size"]


    @page_size.setter
    def page_size(self, value: int) -> None:
        _set_attribute(self._attributes, "ListModelVersionsRequest", "page_size", value, int, "")


    @property
    def page_token(self) -> str:
        """The next_page_token value returned from a previous List request, if any."""
        return self._attributes["page_token"]


    @page_token.setter
    def page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListModelVersionsRequest", "page_token", value, str, "")


    @property
    def latest(self) -> bool:
        """Get the latest model versions first."""
        return self._attributes["latest"]


    @latest.setter
    def latest(self, value: bool) -> None:
        _set_attribute(self._attributes, "ListModelVersionsRequest", "latest", value, bool, "")


    @property
    def filters(self) -> List[str]:
        """Filters."""
        return self._attributes["filters"]


    @filters.setter
    def filters(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ListModelVersionsRequest", "filters", value, List[str], "")


    @property
    def ignore_filters(self) -> List[str]:
        """Ignore filters."""
        return self._attributes["ignore_filters"]


    @ignore_filters.setter
    def ignore_filters(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ListModelVersionsRequest", "ignore_filters", value, List[str], "")


    @property
    def start_time(self) -> datetime:
        """Start time."""
        return self._attributes["start_time"]


    @start_time.setter
    def start_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ListModelVersionsRequest", "start_time", value, datetime, "")


    @property
    def end_time(self) -> datetime:
        """End time."""
        return self._attributes["end_time"]


    @end_time.setter
    def end_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ListModelVersionsRequest", "end_time", value, datetime, "")


    @property
    def all_projects(self) -> bool:
        """All projects."""
        return self._attributes["all_projects"]


    @all_projects.setter
    def all_projects(self, value: bool) -> None:
        _set_attribute(self._attributes, "ListModelVersionsRequest", "all_projects", value, bool, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListModelVersionsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListModelVersionsRequest:
        """Convert object to proto representation."""
        return management_pb2.ListModelVersionsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListModelVersionsRequest object " + repr(self.to_dict()) + ">"


class ListModelVersionsResponse:
    """List model versions response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , model_versions: List[ModelVersion] = []
        , next_page_token: str = ""
    , **kwargs) -> ListModelVersionsResponse:
        self._attributes = dict()
        self.model_versions = model_versions
        self.next_page_token = next_page_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def model_versions(self) -> List[ModelVersion]:
        """Model versions."""
        return self._attributes["model_versions"]


    @model_versions.setter
    def model_versions(self, value: List[ModelVersion]) -> None:
        _set_attribute(self._attributes, "ListModelVersionsResponse", "model_versions", value, List[ModelVersion], "")


    @property
    def next_page_token(self) -> str:
        """Next page token."""
        return self._attributes["next_page_token"]


    @next_page_token.setter
    def next_page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListModelVersionsResponse", "next_page_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListModelVersionsResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListModelVersionsResponse:
        """Convert object to proto representation."""
        return management_pb2.ListModelVersionsResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListModelVersionsResponse object " + repr(self.to_dict()) + ">"


class TrainModelRequest:
    """Train model request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , system_time: datetime = None
        , visible_start_time: datetime = None
        , visible_stop_time: datetime = None
    , **kwargs) -> TrainModelRequest:
        self._attributes = dict()
        self.name = name
        self.system_time = system_time
        self.visible_start_time = visible_start_time
        self.visible_stop_time = visible_stop_time

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "TrainModelRequest", "name", value, str, "")


    @property
    def system_time(self) -> datetime:
        """System time."""
        return self._attributes["system_time"]


    @system_time.setter
    def system_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "TrainModelRequest", "system_time", value, datetime, "")


    @property
    def visible_start_time(self) -> datetime:
        """Visible start time."""
        return self._attributes["visible_start_time"]


    @visible_start_time.setter
    def visible_start_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "TrainModelRequest", "visible_start_time", value, datetime, "")


    @property
    def visible_stop_time(self) -> datetime:
        """Visible stop time."""
        return self._attributes["visible_stop_time"]


    @visible_stop_time.setter
    def visible_stop_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "TrainModelRequest", "visible_stop_time", value, datetime, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.TrainModelRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.TrainModelRequest:
        """Convert object to proto representation."""
        return management_pb2.TrainModelRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<TrainModelRequest object " + repr(self.to_dict()) + ">"


class CancelTrainingRequest:
    """Cancel training request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> CancelTrainingRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "CancelTrainingRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.CancelTrainingRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.CancelTrainingRequest:
        """Convert object to proto representation."""
        return management_pb2.CancelTrainingRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<CancelTrainingRequest object " + repr(self.to_dict()) + ">"


class GetTrainingMetricsRequest:
    """Get training metrics request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , experiment: str = ""
    , **kwargs) -> GetTrainingMetricsRequest:
        self._attributes = dict()
        self.experiment = experiment

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def experiment(self) -> str:
        """Experiment."""
        return self._attributes["experiment"]


    @experiment.setter
    def experiment(self, value: str) -> None:
        _set_attribute(self._attributes, "GetTrainingMetricsRequest", "experiment", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetTrainingMetricsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetTrainingMetricsRequest:
        """Convert object to proto representation."""
        return management_pb2.GetTrainingMetricsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetTrainingMetricsRequest object " + repr(self.to_dict()) + ">"


class GetTrainingMetricsResponse:
    """Get training metrics response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , training_metrics: List[TrainingMetrics] = []
    , **kwargs) -> GetTrainingMetricsResponse:
        self._attributes = dict()
        self.training_metrics = training_metrics

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def training_metrics(self) -> List[TrainingMetrics]:
        """Training metrics."""
        return self._attributes["training_metrics"]


    @training_metrics.setter
    def training_metrics(self, value: List[TrainingMetrics]) -> None:
        _set_attribute(self._attributes, "GetTrainingMetricsResponse", "training_metrics", value, List[TrainingMetrics], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetTrainingMetricsResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetTrainingMetricsResponse:
        """Convert object to proto representation."""
        return management_pb2.GetTrainingMetricsResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetTrainingMetricsResponse object " + repr(self.to_dict()) + ">"


class ListTrainingMetricsRequest:
    """List training metrics request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , model: str = ""
        , page_token: str = ""
        , page_size: int = 0
    , **kwargs) -> ListTrainingMetricsRequest:
        self._attributes = dict()
        self.model = model
        self.page_token = page_token
        self.page_size = page_size

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def model(self) -> str:
        """Model."""
        return self._attributes["model"]


    @model.setter
    def model(self, value: str) -> None:
        _set_attribute(self._attributes, "ListTrainingMetricsRequest", "model", value, str, "")


    @property
    def page_token(self) -> str:
        """Page token."""
        return self._attributes["page_token"]


    @page_token.setter
    def page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListTrainingMetricsRequest", "page_token", value, str, "")


    @property
    def page_size(self) -> int:
        """Page size."""
        return self._attributes["page_size"]


    @page_size.setter
    def page_size(self, value: int) -> None:
        _set_attribute(self._attributes, "ListTrainingMetricsRequest", "page_size", value, int, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListTrainingMetricsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListTrainingMetricsRequest:
        """Convert object to proto representation."""
        return management_pb2.ListTrainingMetricsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListTrainingMetricsRequest object " + repr(self.to_dict()) + ">"


class ListTrainingMetricsResponse:
    """List training metrics response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , training_metrics: List[TrainingMetrics] = []
        , next_page_token: str = ""
    , **kwargs) -> ListTrainingMetricsResponse:
        self._attributes = dict()
        self.training_metrics = training_metrics
        self.next_page_token = next_page_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def training_metrics(self) -> List[TrainingMetrics]:
        """Training metrics."""
        return self._attributes["training_metrics"]


    @training_metrics.setter
    def training_metrics(self, value: List[TrainingMetrics]) -> None:
        _set_attribute(self._attributes, "ListTrainingMetricsResponse", "training_metrics", value, List[TrainingMetrics], "")


    @property
    def next_page_token(self) -> str:
        """Next page token."""
        return self._attributes["next_page_token"]


    @next_page_token.setter
    def next_page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListTrainingMetricsResponse", "next_page_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListTrainingMetricsResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListTrainingMetricsResponse:
        """Convert object to proto representation."""
        return management_pb2.ListTrainingMetricsResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListTrainingMetricsResponse object " + repr(self.to_dict()) + ">"


class GetExperimentRequest:
    """Get experiment request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetExperimentRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetExperimentRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetExperimentRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetExperimentRequest:
        """Convert object to proto representation."""
        return management_pb2.GetExperimentRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetExperimentRequest object " + repr(self.to_dict()) + ">"


class BatchGetExperimentsRequest:
    """Batch get experiments request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , names: List[str] = []
    , **kwargs) -> BatchGetExperimentsRequest:
        self._attributes = dict()
        self.parent = parent
        self.names = names

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "BatchGetExperimentsRequest", "parent", value, str, "")


    @property
    def names(self) -> List[str]:
        """Names."""
        return self._attributes["names"]


    @names.setter
    def names(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "BatchGetExperimentsRequest", "names", value, List[str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BatchGetExperimentsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BatchGetExperimentsRequest:
        """Convert object to proto representation."""
        return management_pb2.BatchGetExperimentsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchGetExperimentsRequest object " + repr(self.to_dict()) + ">"


class BatchGetExperimentsResponse:
    """Batch get experiments response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , experiments: List[Experiment] = []
    , **kwargs) -> BatchGetExperimentsResponse:
        self._attributes = dict()
        self.experiments = experiments

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def experiments(self) -> List[Experiment]:
        """Experiments."""
        return self._attributes["experiments"]


    @experiments.setter
    def experiments(self, value: List[Experiment]) -> None:
        _set_attribute(self._attributes, "BatchGetExperimentsResponse", "experiments", value, List[Experiment], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BatchGetExperimentsResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BatchGetExperimentsResponse:
        """Convert object to proto representation."""
        return management_pb2.BatchGetExperimentsResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchGetExperimentsResponse object " + repr(self.to_dict()) + ">"


class ListExperimentsRequest:
    """List experiments request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , page_size: int = 0
        , page_token: str = ""
        , filters: List[str] = []
        , ignore_filters: List[str] = []
        , start_time: datetime = None
        , end_time: datetime = None
        , all_projects: bool = False
    , **kwargs) -> ListExperimentsRequest:
        self._attributes = dict()
        self.parent = parent
        self.page_size = page_size
        self.page_token = page_token
        self.filters = filters
        self.ignore_filters = ignore_filters
        self.start_time = start_time
        self.end_time = end_time
        self.all_projects = all_projects

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "ListExperimentsRequest", "parent", value, str, "")


    @property
    def page_size(self) -> int:
        """The maximum number of items to return."""
        return self._attributes["page_size"]


    @page_size.setter
    def page_size(self, value: int) -> None:
        _set_attribute(self._attributes, "ListExperimentsRequest", "page_size", value, int, "")


    @property
    def page_token(self) -> str:
        """The next_page_token value returned from a previous List request, if any."""
        return self._attributes["page_token"]


    @page_token.setter
    def page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListExperimentsRequest", "page_token", value, str, "")


    @property
    def filters(self) -> List[str]:
        """Filters."""
        return self._attributes["filters"]


    @filters.setter
    def filters(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ListExperimentsRequest", "filters", value, List[str], "")


    @property
    def ignore_filters(self) -> List[str]:
        """Ignore filters."""
        return self._attributes["ignore_filters"]


    @ignore_filters.setter
    def ignore_filters(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ListExperimentsRequest", "ignore_filters", value, List[str], "")


    @property
    def start_time(self) -> datetime:
        """Start time."""
        return self._attributes["start_time"]


    @start_time.setter
    def start_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ListExperimentsRequest", "start_time", value, datetime, "")


    @property
    def end_time(self) -> datetime:
        """End time."""
        return self._attributes["end_time"]


    @end_time.setter
    def end_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ListExperimentsRequest", "end_time", value, datetime, "")


    @property
    def all_projects(self) -> bool:
        """All projects."""
        return self._attributes["all_projects"]


    @all_projects.setter
    def all_projects(self, value: bool) -> None:
        _set_attribute(self._attributes, "ListExperimentsRequest", "all_projects", value, bool, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListExperimentsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListExperimentsRequest:
        """Convert object to proto representation."""
        return management_pb2.ListExperimentsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListExperimentsRequest object " + repr(self.to_dict()) + ">"


class ListExperimentsResponse:
    """List experiments response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , experiments: List[Experiment] = []
        , next_page_token: str = ""
    , **kwargs) -> ListExperimentsResponse:
        self._attributes = dict()
        self.experiments = experiments
        self.next_page_token = next_page_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def experiments(self) -> List[Experiment]:
        """Experiments."""
        return self._attributes["experiments"]


    @experiments.setter
    def experiments(self, value: List[Experiment]) -> None:
        _set_attribute(self._attributes, "ListExperimentsResponse", "experiments", value, List[Experiment], "")


    @property
    def next_page_token(self) -> str:
        """Next page token."""
        return self._attributes["next_page_token"]


    @next_page_token.setter
    def next_page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListExperimentsResponse", "next_page_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListExperimentsResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListExperimentsResponse:
        """Convert object to proto representation."""
        return management_pb2.ListExperimentsResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListExperimentsResponse object " + repr(self.to_dict()) + ">"


class CreateBatchPredictionRequest:
    """Create batch prediction request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , model: str = ""
        , source_type: BatchPredictionStoreType = 0
        , source: str = ""
        , dest_type: BatchPredictionStoreType = 0
        , incremental: bool = False
        , prediction_model: str = ""
    , **kwargs) -> CreateBatchPredictionRequest:
        self._attributes = dict()
        self.model = model
        self.source_type = source_type
        self.source = source
        self.dest_type = dest_type
        self.incremental = incremental
        self.prediction_model = prediction_model

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def model(self) -> str:
        """Model."""
        return self._attributes["model"]


    @model.setter
    def model(self, value: str) -> None:
        _set_attribute(self._attributes, "CreateBatchPredictionRequest", "model", value, str, "")


    @property
    def source_type(self) -> BatchPredictionStoreType:
        """Source type."""
        return self._attributes["source_type"]


    @source_type.setter
    def source_type(self, value: BatchPredictionStoreType) -> None:
        _set_attribute(self._attributes, "CreateBatchPredictionRequest", "source_type", value, BatchPredictionStoreType, "")


    @property
    def source(self) -> str:
        """Source."""
        return self._attributes["source"]


    @source.setter
    def source(self, value: str) -> None:
        _set_attribute(self._attributes, "CreateBatchPredictionRequest", "source", value, str, "")


    @property
    def dest_type(self) -> BatchPredictionStoreType:
        """Dest type."""
        return self._attributes["dest_type"]


    @dest_type.setter
    def dest_type(self, value: BatchPredictionStoreType) -> None:
        _set_attribute(self._attributes, "CreateBatchPredictionRequest", "dest_type", value, BatchPredictionStoreType, "")


    @property
    def incremental(self) -> bool:
        """Incremental."""
        return self._attributes["incremental"]


    @incremental.setter
    def incremental(self, value: bool) -> None:
        _set_attribute(self._attributes, "CreateBatchPredictionRequest", "incremental", value, bool, "")


    @property
    def prediction_model(self) -> str:
        """Prediction model."""
        return self._attributes["prediction_model"]


    @prediction_model.setter
    def prediction_model(self, value: str) -> None:
        _set_attribute(self._attributes, "CreateBatchPredictionRequest", "prediction_model", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.CreateBatchPredictionRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.CreateBatchPredictionRequest:
        """Convert object to proto representation."""
        return management_pb2.CreateBatchPredictionRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<CreateBatchPredictionRequest object " + repr(self.to_dict()) + ">"


class ListBatchPredictionsRequest:
    """List batch predictions request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , page_size: int = 0
        , page_token: str = ""
        , latest: bool = False
        , filters: List[str] = []
        , ignore_filters: List[str] = []
        , start_time: datetime = None
        , end_time: datetime = None
        , all_projects: bool = False
    , **kwargs) -> ListBatchPredictionsRequest:
        self._attributes = dict()
        self.parent = parent
        self.page_size = page_size
        self.page_token = page_token
        self.latest = latest
        self.filters = filters
        self.ignore_filters = ignore_filters
        self.start_time = start_time
        self.end_time = end_time
        self.all_projects = all_projects

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "ListBatchPredictionsRequest", "parent", value, str, "")


    @property
    def page_size(self) -> int:
        """The maximum number of items to return."""
        return self._attributes["page_size"]


    @page_size.setter
    def page_size(self, value: int) -> None:
        _set_attribute(self._attributes, "ListBatchPredictionsRequest", "page_size", value, int, "")


    @property
    def page_token(self) -> str:
        """The next_page_token value returned from a previous List request, if any."""
        return self._attributes["page_token"]


    @page_token.setter
    def page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListBatchPredictionsRequest", "page_token", value, str, "")


    @property
    def latest(self) -> bool:
        """Get the latest batch predictions first."""
        return self._attributes["latest"]


    @latest.setter
    def latest(self, value: bool) -> None:
        _set_attribute(self._attributes, "ListBatchPredictionsRequest", "latest", value, bool, "")


    @property
    def filters(self) -> List[str]:
        """Filters."""
        return self._attributes["filters"]


    @filters.setter
    def filters(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ListBatchPredictionsRequest", "filters", value, List[str], "")


    @property
    def ignore_filters(self) -> List[str]:
        """Ignore filters."""
        return self._attributes["ignore_filters"]


    @ignore_filters.setter
    def ignore_filters(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ListBatchPredictionsRequest", "ignore_filters", value, List[str], "")


    @property
    def start_time(self) -> datetime:
        """Start time."""
        return self._attributes["start_time"]


    @start_time.setter
    def start_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ListBatchPredictionsRequest", "start_time", value, datetime, "")


    @property
    def end_time(self) -> datetime:
        """End time."""
        return self._attributes["end_time"]


    @end_time.setter
    def end_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ListBatchPredictionsRequest", "end_time", value, datetime, "")


    @property
    def all_projects(self) -> bool:
        """All projects."""
        return self._attributes["all_projects"]


    @all_projects.setter
    def all_projects(self, value: bool) -> None:
        _set_attribute(self._attributes, "ListBatchPredictionsRequest", "all_projects", value, bool, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListBatchPredictionsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListBatchPredictionsRequest:
        """Convert object to proto representation."""
        return management_pb2.ListBatchPredictionsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListBatchPredictionsRequest object " + repr(self.to_dict()) + ">"


class ListBatchPredictionsResponse:
    """List batch predictions response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , batch_predictions: List[BatchPrediction] = []
        , next_page_token: str = ""
    , **kwargs) -> ListBatchPredictionsResponse:
        self._attributes = dict()
        self.batch_predictions = batch_predictions
        self.next_page_token = next_page_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def batch_predictions(self) -> List[BatchPrediction]:
        """Batch predictions."""
        return self._attributes["batch_predictions"]


    @batch_predictions.setter
    def batch_predictions(self, value: List[BatchPrediction]) -> None:
        _set_attribute(self._attributes, "ListBatchPredictionsResponse", "batch_predictions", value, List[BatchPrediction], "")


    @property
    def next_page_token(self) -> str:
        """Next page token."""
        return self._attributes["next_page_token"]


    @next_page_token.setter
    def next_page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListBatchPredictionsResponse", "next_page_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListBatchPredictionsResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListBatchPredictionsResponse:
        """Convert object to proto representation."""
        return management_pb2.ListBatchPredictionsResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListBatchPredictionsResponse object " + repr(self.to_dict()) + ">"


class BatchPredictionRequest:
    """Batch prediction request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> BatchPredictionRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "BatchPredictionRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BatchPredictionRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BatchPredictionRequest:
        """Convert object to proto representation."""
        return management_pb2.BatchPredictionRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchPredictionRequest object " + repr(self.to_dict()) + ">"


class BatchGetBatchPredictionsRequest:
    """Batch get batch predictions request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , names: List[str] = []
    , **kwargs) -> BatchGetBatchPredictionsRequest:
        self._attributes = dict()
        self.parent = parent
        self.names = names

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "BatchGetBatchPredictionsRequest", "parent", value, str, "")


    @property
    def names(self) -> List[str]:
        """Names."""
        return self._attributes["names"]


    @names.setter
    def names(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "BatchGetBatchPredictionsRequest", "names", value, List[str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BatchGetBatchPredictionsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BatchGetBatchPredictionsRequest:
        """Convert object to proto representation."""
        return management_pb2.BatchGetBatchPredictionsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchGetBatchPredictionsRequest object " + repr(self.to_dict()) + ">"


class BatchGetBatchPredictionsResponse:
    """Batch get batch predictions response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , batch_predictions: List[BatchPrediction] = []
    , **kwargs) -> BatchGetBatchPredictionsResponse:
        self._attributes = dict()
        self.batch_predictions = batch_predictions

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def batch_predictions(self) -> List[BatchPrediction]:
        """Batch predictions."""
        return self._attributes["batch_predictions"]


    @batch_predictions.setter
    def batch_predictions(self, value: List[BatchPrediction]) -> None:
        _set_attribute(self._attributes, "BatchGetBatchPredictionsResponse", "batch_predictions", value, List[BatchPrediction], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BatchGetBatchPredictionsResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BatchGetBatchPredictionsResponse:
        """Convert object to proto representation."""
        return management_pb2.BatchGetBatchPredictionsResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchGetBatchPredictionsResponse object " + repr(self.to_dict()) + ">"


class GetServingDataRequest:
    """Get serving data request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , query: Query = None
        , overrides: str = ""
        , event_time: datetime = None
    , **kwargs) -> GetServingDataRequest:
        self._attributes = dict()
        self.query = query
        self.overrides = overrides
        self.event_time = event_time

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def query(self) -> Query:
        """Continual intermediate query for building
 serving data."""
        return self._attributes["query"]


    @query.setter
    def query(self, value: Query) -> None:
        _set_attribute(self._attributes, "GetServingDataRequest", "query", value, Query, "")


    @property
    def overrides(self) -> str:
        """overrides in string encoded json"""
        return self._attributes["overrides"]


    @overrides.setter
    def overrides(self, value: str) -> None:
        _set_attribute(self._attributes, "GetServingDataRequest", "overrides", value, str, "")


    @property
    def event_time(self) -> datetime:
        """For timeseries event instance."""
        return self._attributes["event_time"]


    @event_time.setter
    def event_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "GetServingDataRequest", "event_time", value, datetime, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetServingDataRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetServingDataRequest:
        """Convert object to proto representation."""
        return management_pb2.GetServingDataRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetServingDataRequest object " + repr(self.to_dict()) + ">"


class GetServingDataResponse:
    """Get serving data response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , value: List[str] = []
    , **kwargs) -> GetServingDataResponse:
        self._attributes = dict()
        self.value = value

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def value(self) -> List[str]:
        """Value."""
        return self._attributes["value"]


    @value.setter
    def value(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "GetServingDataResponse", "value", value, List[str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetServingDataResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetServingDataResponse:
        """Convert object to proto representation."""
        return management_pb2.GetServingDataResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetServingDataResponse object " + repr(self.to_dict()) + ">"


class GetTrainingDataRequest:
    """Get training data request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , query: Query = None
    , **kwargs) -> GetTrainingDataRequest:
        self._attributes = dict()
        self.query = query

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def query(self) -> Query:
        """Continual intermediate query for building
 serving data."""
        return self._attributes["query"]


    @query.setter
    def query(self, value: Query) -> None:
        _set_attribute(self._attributes, "GetTrainingDataRequest", "query", value, Query, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetTrainingDataRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetTrainingDataRequest:
        """Convert object to proto representation."""
        return management_pb2.GetTrainingDataRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetTrainingDataRequest object " + repr(self.to_dict()) + ">"


class GetTrainingDataResponse:
    """Get training data response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , value: List[str] = []
    , **kwargs) -> GetTrainingDataResponse:
        self._attributes = dict()
        self.value = value

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def value(self) -> List[str]:
        """Value."""
        return self._attributes["value"]


    @value.setter
    def value(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "GetTrainingDataResponse", "value", value, List[str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetTrainingDataResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetTrainingDataResponse:
        """Convert object to proto representation."""
        return management_pb2.GetTrainingDataResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetTrainingDataResponse object " + repr(self.to_dict()) + ">"


class BrowseDataWarehouseRequest:
    """Browse data warehouse request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , object_type: BrowseDataWarehouseRequestObjectType = 0
        , project: str = ""
        , database: str = ""
        , schema: str = ""
        , table: str = ""
    , **kwargs) -> BrowseDataWarehouseRequest:
        self._attributes = dict()
        self.object_type = object_type
        self.project = project
        self.database = database
        self.schema = schema
        self.table = table

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def object_type(self) -> BrowseDataWarehouseRequestObjectType:
        """Object type."""
        return self._attributes["object_type"]


    @object_type.setter
    def object_type(self, value: BrowseDataWarehouseRequestObjectType) -> None:
        _set_attribute(self._attributes, "BrowseDataWarehouseRequest", "object_type", value, BrowseDataWarehouseRequestObjectType, "")


    @property
    def project(self) -> str:
        """Project."""
        return self._attributes["project"]


    @project.setter
    def project(self, value: str) -> None:
        _set_attribute(self._attributes, "BrowseDataWarehouseRequest", "project", value, str, "")


    @property
    def database(self) -> str:
        """Database."""
        return self._attributes["database"]


    @database.setter
    def database(self, value: str) -> None:
        _set_attribute(self._attributes, "BrowseDataWarehouseRequest", "database", value, str, "")


    @property
    def schema(self) -> str:
        """Schema."""
        return self._attributes["schema"]


    @schema.setter
    def schema(self, value: str) -> None:
        _set_attribute(self._attributes, "BrowseDataWarehouseRequest", "schema", value, str, "")


    @property
    def table(self) -> str:
        """Table."""
        return self._attributes["table"]


    @table.setter
    def table(self, value: str) -> None:
        _set_attribute(self._attributes, "BrowseDataWarehouseRequest", "table", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BrowseDataWarehouseRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BrowseDataWarehouseRequest:
        """Convert object to proto representation."""
        return management_pb2.BrowseDataWarehouseRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BrowseDataWarehouseRequest object " + repr(self.to_dict()) + ">"


class BrowseDataWarehouseResponse:
    """Browse data warehouse response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , object_type: BrowseDataWarehouseRequestObjectType = 0
        , names: List[str] = []
        , types: Dict[str, str] = None
    , **kwargs) -> BrowseDataWarehouseResponse:
        self._attributes = dict()
        self.object_type = object_type
        self.names = names
        self.types = types

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def object_type(self) -> BrowseDataWarehouseRequestObjectType:
        """Object type."""
        return self._attributes["object_type"]


    @object_type.setter
    def object_type(self, value: BrowseDataWarehouseRequestObjectType) -> None:
        _set_attribute(self._attributes, "BrowseDataWarehouseResponse", "object_type", value, BrowseDataWarehouseRequestObjectType, "")


    @property
    def names(self) -> List[str]:
        """Names."""
        return self._attributes["names"]


    @names.setter
    def names(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "BrowseDataWarehouseResponse", "names", value, List[str], "")


    @property
    def types(self) -> Dict[str, str]:
        """Types."""
        return self._attributes["types"]


    @types.setter
    def types(self, value: Dict[str, str]) -> None:
        _set_attribute(self._attributes, "BrowseDataWarehouseResponse", "types", value, Dict[str, str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BrowseDataWarehouseResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BrowseDataWarehouseResponse:
        """Convert object to proto representation."""
        return management_pb2.BrowseDataWarehouseResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BrowseDataWarehouseResponse object " + repr(self.to_dict()) + ">"


class SeedRequest:
    """Seed request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , project: str = ""
        , file_path: str = ""
        , table_name: str = ""
    , **kwargs) -> SeedRequest:
        self._attributes = dict()
        self.project = project
        self.file_path = file_path
        self.table_name = table_name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def project(self) -> str:
        """Project."""
        return self._attributes["project"]


    @project.setter
    def project(self, value: str) -> None:
        _set_attribute(self._attributes, "SeedRequest", "project", value, str, "")


    @property
    def file_path(self) -> str:
        """File path."""
        return self._attributes["file_path"]


    @file_path.setter
    def file_path(self, value: str) -> None:
        _set_attribute(self._attributes, "SeedRequest", "file_path", value, str, "")


    @property
    def table_name(self) -> str:
        """Table name."""
        return self._attributes["table_name"]


    @table_name.setter
    def table_name(self, value: str) -> None:
        _set_attribute(self._attributes, "SeedRequest", "table_name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.SeedRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.SeedRequest:
        """Convert object to proto representation."""
        return management_pb2.SeedRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<SeedRequest object " + repr(self.to_dict()) + ">"


class SeedResponse:
    """Seed response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , schema_name: str = ""
        , table_name: str = ""
    , **kwargs) -> SeedResponse:
        self._attributes = dict()
        self.schema_name = schema_name
        self.table_name = table_name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def schema_name(self) -> str:
        """Schema name."""
        return self._attributes["schema_name"]


    @schema_name.setter
    def schema_name(self, value: str) -> None:
        _set_attribute(self._attributes, "SeedResponse", "schema_name", value, str, "")


    @property
    def table_name(self) -> str:
        """Table name."""
        return self._attributes["table_name"]


    @table_name.setter
    def table_name(self, value: str) -> None:
        _set_attribute(self._attributes, "SeedResponse", "table_name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.SeedResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.SeedResponse:
        """Convert object to proto representation."""
        return management_pb2.SeedResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<SeedResponse object " + repr(self.to_dict()) + ">"


class YamlDiffRequest:
    """Yaml diff request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , right: str = ""
        , right_text: str = ""
        , left: str = ""
        , left_text: str = ""
        , parent: str = ""
    , **kwargs) -> YamlDiffRequest:
        self._attributes = dict()
        self.right = right
        self.right_text = right_text
        self.left = left
        self.left_text = left_text
        self.parent = parent

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def right(self) -> str:
        """Right."""
        return self._attributes["right"]


    @right.setter
    def right(self, value: str) -> None:
        _set_attribute(self._attributes, "YamlDiffRequest", "right", value, str, "")


    @property
    def right_text(self) -> str:
        """Right text."""
        return self._attributes["right_text"]


    @right_text.setter
    def right_text(self, value: str) -> None:
        _set_attribute(self._attributes, "YamlDiffRequest", "right_text", value, str, "")


    @property
    def left(self) -> str:
        """Left."""
        return self._attributes["left"]


    @left.setter
    def left(self, value: str) -> None:
        _set_attribute(self._attributes, "YamlDiffRequest", "left", value, str, "")


    @property
    def left_text(self) -> str:
        """Left text."""
        return self._attributes["left_text"]


    @left_text.setter
    def left_text(self, value: str) -> None:
        _set_attribute(self._attributes, "YamlDiffRequest", "left_text", value, str, "")


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "YamlDiffRequest", "parent", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.YamlDiffRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.YamlDiffRequest:
        """Convert object to proto representation."""
        return management_pb2.YamlDiffRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<YamlDiffRequest object " + repr(self.to_dict()) + ">"


class YamlDiffResponse:
    """Yaml diff response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , text: str = ""
    , **kwargs) -> YamlDiffResponse:
        self._attributes = dict()
        self.text = text

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def text(self) -> str:
        """Text."""
        return self._attributes["text"]


    @text.setter
    def text(self, value: str) -> None:
        _set_attribute(self._attributes, "YamlDiffResponse", "text", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.YamlDiffResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.YamlDiffResponse:
        """Convert object to proto representation."""
        return management_pb2.YamlDiffResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<YamlDiffResponse object " + repr(self.to_dict()) + ">"


class GetModelQueryRequest:
    """Get model query request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , model: Model = None
        , additional_feature_sets: List[FeatureSet] = []
    , **kwargs) -> GetModelQueryRequest:
        self._attributes = dict()
        self.name = name
        self.model = model
        self.additional_feature_sets = additional_feature_sets

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetModelQueryRequest", "name", value, str, "")


    @property
    def model(self) -> Model:
        """Model."""
        return self._attributes["model"]


    @model.setter
    def model(self, value: Model) -> None:
        _set_attribute(self._attributes, "GetModelQueryRequest", "model", value, Model, "")


    @property
    def additional_feature_sets(self) -> List[FeatureSet]:
        """Additional feature sets."""
        return self._attributes["additional_feature_sets"]


    @additional_feature_sets.setter
    def additional_feature_sets(self, value: List[FeatureSet]) -> None:
        _set_attribute(self._attributes, "GetModelQueryRequest", "additional_feature_sets", value, List[FeatureSet], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetModelQueryRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetModelQueryRequest:
        """Convert object to proto representation."""
        return management_pb2.GetModelQueryRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetModelQueryRequest object " + repr(self.to_dict()) + ">"


class GetModelQueryResponse:
    """Get model query response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , query_json: str = ""
    , **kwargs) -> GetModelQueryResponse:
        self._attributes = dict()
        self.query_json = query_json

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def query_json(self) -> str:
        """Query json."""
        return self._attributes["query_json"]


    @query_json.setter
    def query_json(self, value: str) -> None:
        _set_attribute(self._attributes, "GetModelQueryResponse", "query_json", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetModelQueryResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetModelQueryResponse:
        """Convert object to proto representation."""
        return management_pb2.GetModelQueryResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetModelQueryResponse object " + repr(self.to_dict()) + ">"


class GetSchemaGraphRequest:
    """Get schema graph request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , additional_feature_sets: List[FeatureSet] = []
        , additional_models: List[Model] = []
    , **kwargs) -> GetSchemaGraphRequest:
        self._attributes = dict()
        self.name = name
        self.additional_feature_sets = additional_feature_sets
        self.additional_models = additional_models

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetSchemaGraphRequest", "name", value, str, "")


    @property
    def additional_feature_sets(self) -> List[FeatureSet]:
        """Additional feature sets."""
        return self._attributes["additional_feature_sets"]


    @additional_feature_sets.setter
    def additional_feature_sets(self, value: List[FeatureSet]) -> None:
        _set_attribute(self._attributes, "GetSchemaGraphRequest", "additional_feature_sets", value, List[FeatureSet], "")


    @property
    def additional_models(self) -> List[Model]:
        """Additional models."""
        return self._attributes["additional_models"]


    @additional_models.setter
    def additional_models(self, value: List[Model]) -> None:
        _set_attribute(self._attributes, "GetSchemaGraphRequest", "additional_models", value, List[Model], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetSchemaGraphRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetSchemaGraphRequest:
        """Convert object to proto representation."""
        return management_pb2.GetSchemaGraphRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetSchemaGraphRequest object " + repr(self.to_dict()) + ">"


class GetSchemaGraphResponse:
    """Get schema graph response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , graph_json: str = ""
    , **kwargs) -> GetSchemaGraphResponse:
        self._attributes = dict()
        self.graph_json = graph_json

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def graph_json(self) -> str:
        """Graph json."""
        return self._attributes["graph_json"]


    @graph_json.setter
    def graph_json(self, value: str) -> None:
        _set_attribute(self._attributes, "GetSchemaGraphResponse", "graph_json", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetSchemaGraphResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetSchemaGraphResponse:
        """Convert object to proto representation."""
        return management_pb2.GetSchemaGraphResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetSchemaGraphResponse object " + repr(self.to_dict()) + ">"


class CreateEnvironmentRequest:
    """Create environment request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , environment_id: str = ""
        , source: str = ""
        , data_store: DataStore = None
        , scheduling_enabled: bool = False
    , **kwargs) -> CreateEnvironmentRequest:
        self._attributes = dict()
        self.parent = parent
        self.environment_id = environment_id
        self.source = source
        self.data_store = data_store
        self.scheduling_enabled = scheduling_enabled

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "CreateEnvironmentRequest", "parent", value, str, "")


    @property
    def environment_id(self) -> str:
        """Optional user-readable ID to project, which will
 become the last element of the resource name.
 https://aip.dev/133#user-specified-ids"""
        return self._attributes["environment_id"]


    @environment_id.setter
    def environment_id(self, value: str) -> None:
        _set_attribute(self._attributes, "CreateEnvironmentRequest", "environment_id", value, str, "")


    @property
    def source(self) -> str:
        """Source."""
        return self._attributes["source"]


    @source.setter
    def source(self, value: str) -> None:
        _set_attribute(self._attributes, "CreateEnvironmentRequest", "source", value, str, "")


    @property
    def data_store(self) -> DataStore:
        """Data store."""
        return self._attributes["data_store"]


    @data_store.setter
    def data_store(self, value: DataStore) -> None:
        _set_attribute(self._attributes, "CreateEnvironmentRequest", "data_store", value, DataStore, "")


    @property
    def scheduling_enabled(self) -> bool:
        """Scheduling enabled."""
        return self._attributes["scheduling_enabled"]


    @scheduling_enabled.setter
    def scheduling_enabled(self, value: bool) -> None:
        _set_attribute(self._attributes, "CreateEnvironmentRequest", "scheduling_enabled", value, bool, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.CreateEnvironmentRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.CreateEnvironmentRequest:
        """Convert object to proto representation."""
        return management_pb2.CreateEnvironmentRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<CreateEnvironmentRequest object " + repr(self.to_dict()) + ">"


class UpdateEnvironmentRequest:
    """Update environment request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , environment: Environment = None
        , update_mask: protobuf.FieldMask = None
    , **kwargs) -> UpdateEnvironmentRequest:
        self._attributes = dict()
        self.environment = environment
        self.update_mask = update_mask

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def environment(self) -> Environment:
        """Environment."""
        return self._attributes["environment"]


    @environment.setter
    def environment(self, value: Environment) -> None:
        _set_attribute(self._attributes, "UpdateEnvironmentRequest", "environment", value, Environment, "")


    @property
    def update_mask(self) -> protobuf.FieldMask:
        """Update mask."""
        return self._attributes["update_mask"]


    @update_mask.setter
    def update_mask(self, value: protobuf.FieldMask) -> None:
        _set_attribute(self._attributes, "UpdateEnvironmentRequest", "update_mask", value, protobuf.FieldMask, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.UpdateEnvironmentRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.UpdateEnvironmentRequest:
        """Convert object to proto representation."""
        return management_pb2.UpdateEnvironmentRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<UpdateEnvironmentRequest object " + repr(self.to_dict()) + ">"


class GetEnvironmentRequest:
    """Get environment request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> GetEnvironmentRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "GetEnvironmentRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetEnvironmentRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetEnvironmentRequest:
        """Convert object to proto representation."""
        return management_pb2.GetEnvironmentRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetEnvironmentRequest object " + repr(self.to_dict()) + ">"


class BatchGetEnvironmentsRequest:
    """Batch get environments request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , names: List[str] = []
    , **kwargs) -> BatchGetEnvironmentsRequest:
        self._attributes = dict()
        self.names = names

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def names(self) -> List[str]:
        """Names."""
        return self._attributes["names"]


    @names.setter
    def names(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "BatchGetEnvironmentsRequest", "names", value, List[str], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BatchGetEnvironmentsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BatchGetEnvironmentsRequest:
        """Convert object to proto representation."""
        return management_pb2.BatchGetEnvironmentsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchGetEnvironmentsRequest object " + repr(self.to_dict()) + ">"


class BatchGetEnvironmentsResponse:
    """Batch get environments response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , environments: List[Environment] = []
    , **kwargs) -> BatchGetEnvironmentsResponse:
        self._attributes = dict()
        self.environments = environments

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def environments(self) -> List[Environment]:
        """Environments."""
        return self._attributes["environments"]


    @environments.setter
    def environments(self, value: List[Environment]) -> None:
        _set_attribute(self._attributes, "BatchGetEnvironmentsResponse", "environments", value, List[Environment], "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.BatchGetEnvironmentsResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.BatchGetEnvironmentsResponse:
        """Convert object to proto representation."""
        return management_pb2.BatchGetEnvironmentsResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<BatchGetEnvironmentsResponse object " + repr(self.to_dict()) + ">"


class DeleteEnvironmentRequest:
    """Delete environment request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
        , delete_schema: bool = False
    , **kwargs) -> DeleteEnvironmentRequest:
        self._attributes = dict()
        self.name = name
        self.delete_schema = delete_schema

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "DeleteEnvironmentRequest", "name", value, str, "")


    @property
    def delete_schema(self) -> bool:
        """Delete schema."""
        return self._attributes["delete_schema"]


    @delete_schema.setter
    def delete_schema(self, value: bool) -> None:
        _set_attribute(self._attributes, "DeleteEnvironmentRequest", "delete_schema", value, bool, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.DeleteEnvironmentRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.DeleteEnvironmentRequest:
        """Convert object to proto representation."""
        return management_pb2.DeleteEnvironmentRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<DeleteEnvironmentRequest object " + repr(self.to_dict()) + ">"


class ListEnvironmentsRequest:
    """List environments request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , parent: str = ""
        , page_size: int = 0
        , page_token: str = ""
        , filters: List[str] = []
        , ignore_filters: List[str] = []
        , start_time: datetime = None
        , end_time: datetime = None
    , **kwargs) -> ListEnvironmentsRequest:
        self._attributes = dict()
        self.parent = parent
        self.page_size = page_size
        self.page_token = page_token
        self.filters = filters
        self.ignore_filters = ignore_filters
        self.start_time = start_time
        self.end_time = end_time

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def parent(self) -> str:
        """Parent."""
        return self._attributes["parent"]


    @parent.setter
    def parent(self, value: str) -> None:
        _set_attribute(self._attributes, "ListEnvironmentsRequest", "parent", value, str, "")


    @property
    def page_size(self) -> int:
        """Page size."""
        return self._attributes["page_size"]


    @page_size.setter
    def page_size(self, value: int) -> None:
        _set_attribute(self._attributes, "ListEnvironmentsRequest", "page_size", value, int, "")


    @property
    def page_token(self) -> str:
        """Page token."""
        return self._attributes["page_token"]


    @page_token.setter
    def page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListEnvironmentsRequest", "page_token", value, str, "")


    @property
    def filters(self) -> List[str]:
        """Filters."""
        return self._attributes["filters"]


    @filters.setter
    def filters(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ListEnvironmentsRequest", "filters", value, List[str], "")


    @property
    def ignore_filters(self) -> List[str]:
        """Ignore filters."""
        return self._attributes["ignore_filters"]


    @ignore_filters.setter
    def ignore_filters(self, value: List[str]) -> None:
        _set_attribute(self._attributes, "ListEnvironmentsRequest", "ignore_filters", value, List[str], "")


    @property
    def start_time(self) -> datetime:
        """Start time."""
        return self._attributes["start_time"]


    @start_time.setter
    def start_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ListEnvironmentsRequest", "start_time", value, datetime, "")


    @property
    def end_time(self) -> datetime:
        """End time."""
        return self._attributes["end_time"]


    @end_time.setter
    def end_time(self, value: datetime) -> None:
        _set_attribute(self._attributes, "ListEnvironmentsRequest", "end_time", value, datetime, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListEnvironmentsRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListEnvironmentsRequest:
        """Convert object to proto representation."""
        return management_pb2.ListEnvironmentsRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListEnvironmentsRequest object " + repr(self.to_dict()) + ">"


class ListEnvironmentsResponse:
    """List environments response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , environments: List[Environment] = []
        , next_page_token: str = ""
    , **kwargs) -> ListEnvironmentsResponse:
        self._attributes = dict()
        self.environments = environments
        self.next_page_token = next_page_token

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def environments(self) -> List[Environment]:
        """Environments."""
        return self._attributes["environments"]


    @environments.setter
    def environments(self, value: List[Environment]) -> None:
        _set_attribute(self._attributes, "ListEnvironmentsResponse", "environments", value, List[Environment], "")


    @property
    def next_page_token(self) -> str:
        """Next page token."""
        return self._attributes["next_page_token"]


    @next_page_token.setter
    def next_page_token(self, value: str) -> None:
        _set_attribute(self._attributes, "ListEnvironmentsResponse", "next_page_token", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.ListEnvironmentsResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.ListEnvironmentsResponse:
        """Convert object to proto representation."""
        return management_pb2.ListEnvironmentsResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<ListEnvironmentsResponse object " + repr(self.to_dict()) + ">"


class TestEnvironmentDataStoreRequest:
    """Test environment data store request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , name: str = ""
    , **kwargs) -> TestEnvironmentDataStoreRequest:
        self._attributes = dict()
        self.name = name

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def name(self) -> str:
        """Name."""
        return self._attributes["name"]


    @name.setter
    def name(self, value: str) -> None:
        _set_attribute(self._attributes, "TestEnvironmentDataStoreRequest", "name", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.TestEnvironmentDataStoreRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.TestEnvironmentDataStoreRequest:
        """Convert object to proto representation."""
        return management_pb2.TestEnvironmentDataStoreRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<TestEnvironmentDataStoreRequest object " + repr(self.to_dict()) + ">"


class TestEnvironmentDataStoreResponse:
    """Test environment data store response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , success: bool = False
        , error_message: str = ""
    , **kwargs) -> TestEnvironmentDataStoreResponse:
        self._attributes = dict()
        self.success = success
        self.error_message = error_message

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def success(self) -> bool:
        """Success."""
        return self._attributes["success"]


    @success.setter
    def success(self, value: bool) -> None:
        _set_attribute(self._attributes, "TestEnvironmentDataStoreResponse", "success", value, bool, "")


    @property
    def error_message(self) -> str:
        """Error message."""
        return self._attributes["error_message"]


    @error_message.setter
    def error_message(self, value: str) -> None:
        _set_attribute(self._attributes, "TestEnvironmentDataStoreResponse", "error_message", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.TestEnvironmentDataStoreResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.TestEnvironmentDataStoreResponse:
        """Convert object to proto representation."""
        return management_pb2.TestEnvironmentDataStoreResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<TestEnvironmentDataStoreResponse object " + repr(self.to_dict()) + ">"


class GetSystemMessageRequest:
    """Get system message request."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
    , **kwargs) -> GetSystemMessageRequest:
        self._attributes = dict()

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetSystemMessageRequest, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetSystemMessageRequest:
        """Convert object to proto representation."""
        return management_pb2.GetSystemMessageRequest(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetSystemMessageRequest object " + repr(self.to_dict()) + ">"


class GetSystemMessageResponse:
    """Get system message response."""

    _attributes: dict
    _client: Any = None
    
    def __init__(self
        , message: str = ""
    , **kwargs) -> GetSystemMessageResponse:
        self._attributes = dict()
        self.message = message

        if "client" in kwargs:
            self._client = kwargs["client"]
        if hasattr(self, "_init"):
            self._init()


    @property
    def message(self) -> str:
        """Message."""
        return self._attributes["message"]


    @message.setter
    def message(self, value: str) -> None:
        _set_attribute(self._attributes, "GetSystemMessageResponse", "message", value, str, "")


    @classmethod
    def from_proto(cls: Type[T], proto: management_pb2.GetSystemMessageResponse, **kwargs) -> T:
        """Convert object from proto representation."""
        return cls(**MessageToDict(proto, preserving_proto_field_name=True), **kwargs)

    def to_proto(self) -> management_pb2.GetSystemMessageResponse:
        """Convert object to proto representation."""
        return management_pb2.GetSystemMessageResponse(**_to_proto_dict(self._attributes))

    def to_dict(self) -> dict:
        """Convert object to plain python dictionary representation."""
        return MessageToDict(
            self.to_proto(), 
            including_default_value_fields=True, 
            preserving_proto_field_name=True,
        )
    
    def __repr__(self) -> str:
        return "<GetSystemMessageResponse object " + repr(self.to_dict()) + ">"
