pub fn builder() -> PyRetryPolicyBuilder {
        PyRetryPolicyBuilder {
            max_attempts: None,
            backoff_strategy: None,
            initial_delay: None,
            max_delay: None,
            retry_condition: None,
            with_jitter: None,
        }
    }

    pub fn default() -> Self {
        Self {
            inner: crate::retry::RetryPolicy::default(),
        }
    }

    pub fn should_retry(&self, attempt: i32, _error_type: &str) -> bool {
        // For now, use a simple retry condition check
        // In the future, this could be enhanced to parse error_type
        attempt < self.inner.max_attempts
    }

    pub fn calculate_delay(&self, attempt: i32) -> f64 {
        let duration = self.inner.calculate_delay(attempt);
        duration.as_secs_f64()
    }

    pub fn max_attempts(&self) -> i32 {
        self.inner.max_attempts
    }

    pub fn initial_delay(&self) -> f64 {
        self.inner.initial_delay.as_secs_f64()
    }

    pub fn max_delay(&self) -> f64 {
        self.inner.max_delay.as_secs_f64()
    }

    pub fn with_jitter(&self) -> bool {
        self.inner.jitter
    }

    pub fn __repr__(&self) -> String {
        format!(
            "RetryPolicy(max_attempts={}, initial_delay={}s, max_delay={}s, jitter={})",
            self.max_attempts(),
            self.initial_delay(),
            self.max_delay(),
            self.with_jitter()
        )
    }

    pub fn fixed() -> Self {
        Self {
            inner: crate::retry::BackoffStrategy::Fixed,
        }
    }

    pub fn linear(multiplier: f64) -> Self {
        Self {
            inner: crate::retry::BackoffStrategy::Linear { multiplier },
        }
    }

    pub fn exponential(base: f64, multiplier: Option<f64>) -> Self {
        Self {
            inner: crate::retry::BackoffStrategy::Exponential {
                base,
                multiplier: multiplier.unwrap_or(1.0),
            },
        }
    }

    pub fn __repr__(&self) -> String {
        match &self.inner {
            crate::retry::BackoffStrategy::Fixed => "BackoffStrategy.Fixed".to_string(),
            crate::retry::BackoffStrategy::Linear { multiplier } => {
                format!("BackoffStrategy.Linear(multiplier={})", multiplier)
            }
            crate::retry::BackoffStrategy::Exponential { base, multiplier } => {
                format!(
                    "BackoffStrategy.Exponential(base={}, multiplier={})",
                    base, multiplier
                )
            }
            crate::retry::BackoffStrategy::Custom { function_name } => {
                format!("BackoffStrategy.Custom(function_name='{}')", function_name)
            }
        }
    }

    pub fn never() -> Self {
        Self {
            inner: crate::retry::RetryCondition::Never,
        }
    }

    pub fn transient_only() -> Self {
        Self {
            inner: crate::retry::RetryCondition::TransientOnly,
        }
    }

    pub fn all_errors() -> Self {
        Self {
            inner: crate::retry::RetryCondition::AllErrors,
        }
    }

    pub fn error_pattern(patterns: Vec<String>) -> Self {
        Self {
            inner: crate::retry::RetryCondition::ErrorPattern { patterns },
        }
    }

    pub fn __repr__(&self) -> String {
        match &self.inner {
            crate::retry::RetryCondition::Never => "RetryCondition.Never".to_string(),
            crate::retry::RetryCondition::TransientOnly => {
                "RetryCondition.TransientOnly".to_string()
            }
            crate::retry::RetryCondition::AllErrors => "RetryCondition.AllErrors".to_string(),
            crate::retry::RetryCondition::ErrorPattern { patterns } => {
                format!("RetryCondition.ErrorPattern(patterns={:?})", patterns)
            }
        }
    }

    pub fn max_attempts(&self, attempts: i32) -> Self {
        let mut new_builder = self.clone();
        new_builder.max_attempts = Some(attempts);
        new_builder
    }

    pub fn initial_delay(&self, delay_seconds: f64) -> Self {
        let mut new_builder = self.clone();
        new_builder.initial_delay = Some(Duration::from_secs_f64(delay_seconds));
        new_builder
    }

    pub fn max_delay(&self, delay_seconds: f64) -> Self {
        let mut new_builder = self.clone();
        new_builder.max_delay = Some(Duration::from_secs_f64(delay_seconds));
        new_builder
    }

    pub fn backoff_strategy(&self, strategy: PyBackoffStrategy) -> Self {
        let mut new_builder = self.clone();
        new_builder.backoff_strategy = Some(strategy.inner);
        new_builder
    }

    pub fn retry_condition(&self, condition: PyRetryCondition) -> Self {
        let mut new_builder = self.clone();
        new_builder.retry_condition = Some(condition.inner);
        new_builder
    }

    pub fn with_jitter(&self, jitter: bool) -> Self {
        let mut new_builder = self.clone();
        new_builder.with_jitter = Some(jitter);
        new_builder
    }

    pub fn build(&self) -> PyRetryPolicy {
        let mut builder = crate::retry::RetryPolicy::builder();

        if let Some(attempts) = self.max_attempts {
            builder = builder.max_attempts(attempts);
        }
        if let Some(strategy) = &self.backoff_strategy {
            builder = builder.backoff_strategy(strategy.clone());
        }
        if let Some(delay) = self.initial_delay {
            builder = builder.initial_delay(delay);
        }
        if let Some(delay) = self.max_delay {
            builder = builder.max_delay(delay);
        }
        if let Some(condition) = &self.retry_condition {
            builder = builder.retry_condition(condition.clone());
        }
        if let Some(jitter) = self.with_jitter {
            builder = builder.with_jitter(jitter);
        }

        PyRetryPolicy {
            inner: builder.build(),
        }
    }

gdoc_arrow_left_alt value_objects rust gdoc_arrow_right_alt