Skip to content

Data Types & Enums

The ReZEN API client provides comprehensive type definitions and enums for type-safe development and better IDE support.

Overview

Type System Benefits

  • Type Safety: Full type hints for all API methods and data structures
  • IDE Support: Enhanced autocompletion and error detection
  • Validation: Automatic data validation using Pydantic models
  • Documentation: Self-documenting code with clear type definitions

Enums

Teams & Organization

TeamStatus

from rezen.enums import TeamStatus

# Available team statuses
TeamStatus.ACTIVE      # Active teams
TeamStatus.INACTIVE    # Inactive teams

TeamType

from rezen.enums import TeamType

# Team classification types
TeamType.PLATINUM      # Platinum level teams
TeamType.GOLD          # Gold level teams
TeamType.SILVER        # Silver level teams
TeamType.BRONZE        # Bronze level teams

SortDirection

from rezen.enums import SortDirection

# Sorting options
SortDirection.ASC      # Ascending order
SortDirection.DESC     # Descending order

SortField

from rezen.enums import SortField

# Available sort fields for teams
SortField.NAME         # Sort by team name
SortField.CREATED_AT   # Sort by creation date
SortField.UPDATED_AT   # Sort by last update
SortField.STATUS       # Sort by status

Usage Example

from rezen import RezenClient
from rezen.enums import TeamStatus, SortField, SortDirection

client = RezenClient()
teams = client.teams.search_teams(
    status=TeamStatus.ACTIVE,
    sort_by=[SortField.NAME, SortField.CREATED_AT],
    sort_direction=SortDirection.ASC
)

Agents & People

AgentSortDirection

from rezen.enums import AgentSortDirection

# Agent-specific sorting
AgentSortDirection.ASC     # Ascending order
AgentSortDirection.DESC    # Descending order

AgentSortField

from rezen.enums import AgentSortField

# Agent sort fields
AgentSortField.FIRST_NAME     # Sort by first name
AgentSortField.LAST_NAME      # Sort by last name
AgentSortField.EMAIL          # Sort by email address
AgentSortField.CREATED_AT     # Sort by creation date

Country

from rezen.enums import Country

# Supported countries
Country.UNITED_STATES     # United States
Country.CANADA            # Canada

StateOrProvince

from rezen.enums import StateOrProvince

# US States
StateOrProvince.ALABAMA
StateOrProvince.ALASKA
StateOrProvince.ARIZONA
StateOrProvince.CALIFORNIA
StateOrProvince.TEXAS
# ... (all US states available)

# Canadian Provinces
StateOrProvince.ALBERTA
StateOrProvince.BRITISH_COLUMBIA
StateOrProvince.ONTARIO
# ... (all Canadian provinces available)

Transactions & Business

ParticipantType

from rezen.enums import ParticipantType

# Transaction participant types
ParticipantType.BUYER         # Buyer in transaction
ParticipantType.SELLER        # Seller in transaction
ParticipantType.AGENT         # Real estate agent
ParticipantType.LENDER        # Mortgage lender
ParticipantType.INSPECTOR     # Property inspector
ParticipantType.APPRAISER     # Property appraiser
ParticipantType.TITLE_COMPANY # Title company

TransactionStatus

from rezen.enums import TransactionStatus

# Transaction lifecycle states
TransactionStatus.DRAFT       # Draft transaction
TransactionStatus.ACTIVE      # Active transaction
TransactionStatus.PENDING     # Pending transaction
TransactionStatus.CLOSED      # Closed transaction
TransactionStatus.CANCELLED   # Cancelled transaction

Auto-Generated API Documentation

The following sections provide auto-generated documentation from the source code:

Core Enums Module

rezen.enums

Shared enums for the ReZEN API client.

Country

Bases: Enum

Country enumeration.

SortDirection

Bases: Enum

Sort direction enumeration used across multiple API endpoints.

StateOrProvince

Bases: Enum

States and provinces enumeration.

Usage Patterns

Type-Safe Development

from typing import List, Optional
from rezen import RezenClient
from rezen.enums import TeamStatus, SortDirection

def get_active_teams(
    client: RezenClient,
    limit: int = 20
) -> List[dict]:
    """Get active teams with type safety."""
    return client.teams.search_teams(
        status=TeamStatus.ACTIVE,  # Type-safe enum usage
        sort_direction=SortDirection.DESC,
        page_size=limit
    )

from rezen.enums import StateOrProvince, Country

# IDE will provide autocompletion for enum values
def search_california_agents():
    return client.agents.search_active_agents(
        country=[Country.UNITED_STATES],
        state_or_province=[StateOrProvince.CALIFORNIA]
    )

Validation Examples

from rezen.enums import TeamStatus

def validate_team_status(status: str) -> bool:
    """Validate team status input."""
    try:
        TeamStatus(status)
        return True
    except ValueError:
        return False

# Usage
if validate_team_status("ACTIVE"):
    print("Valid status")

from rezen.enums import (
    TeamStatus,
    AgentSortField,
    StateOrProvince
)

# Advanced filtering with multiple enums
def advanced_search_example():
    client = RezenClient()

    # Search active teams
    teams = client.teams.search_teams(
        status=TeamStatus.ACTIVE
    )

    # Search California agents sorted by name
    agents = client.agents.search_active_agents(
        state_or_province=[StateOrProvince.CALIFORNIA],
        sort_by=[AgentSortField.LAST_NAME]
    )

    return teams, agents

Best Practices

:material-code-tags: Type Hints

Always Use Type Hints

from typing import List, Optional
from rezen.enums import TeamStatus

def process_teams(
    statuses: List[TeamStatus],
    limit: Optional[int] = None
) -> List[dict]:
    """Process teams with proper type hints."""
    # Implementation with type safety
    pass

:material-import: Import Patterns

Recommended Import Style

# Specific imports for better performance and clarity
from rezen.enums import (
    TeamStatus,
    SortDirection,
    AgentSortField,
    StateOrProvince
)

# Avoid importing the entire module
# from rezen import enums  # Less preferred

:material-bug: Error Handling

Enum Validation

from rezen.enums import TeamStatus

def safe_enum_conversion(value: str) -> Optional[TeamStatus]:
    """Safely convert string to enum."""
    try:
        return TeamStatus(value)
    except ValueError:
        print(f"Invalid team status: {value}")
        return None

Complete Enum Reference

Quick Reference Table

Category Enum Values Description
Teams TeamStatus ACTIVE, INACTIVE Team status states
Teams TeamType PLATINUM, GOLD, SILVER, BRONZE Team classification
Sorting SortDirection ASC, DESC Sort order direction
Teams SortField NAME, CREATED_AT, UPDATED_AT, STATUS Team sort fields
Agents AgentSortDirection ASC, DESC Agent sort direction
Agents AgentSortField FIRST_NAME, LAST_NAME, EMAIL, CREATED_AT Agent sort fields
Geography Country UNITED_STATES, CANADA Supported countries
Geography StateOrProvince All US states & Canadian provinces Geographic regions
Transactions ParticipantType BUYER, SELLER, AGENT, etc. Transaction participants
Transactions TransactionStatus DRAFT, ACTIVE, PENDING, etc. Transaction states

Migration Guide

Upgrading from String Values

If you're migrating from string-based values to enums:

# Old approach with strings
teams = client.teams.search_teams(
    status="ACTIVE",
    sort_direction="DESC"
)

from rezen.enums import TeamStatus, SortDirection

# New approach with enums
teams = client.teams.search_teams(
    status=TeamStatus.ACTIVE,
    sort_direction=SortDirection.DESC
)

Next Steps