Skip to main content

cc_switch/config/
types.rs

1use serde::{Deserialize, Deserializer, Serialize, Serializer};
2use std::collections::BTreeMap;
3
4/// Type alias for configuration map
5type ConfigMap = BTreeMap<String, Configuration>;
6/// Type alias for environment variable map
7type EnvMap = BTreeMap<String, String>;
8/// Type alias for JSON value map
9type JsonMap = BTreeMap<String, serde_json::Value>;
10/// Type alias for Codex configuration map
11type CodexConfigMap = BTreeMap<String, crate::codex::CodexConfiguration>;
12/// Type alias for OMP configuration map
13type OmpConfigMap = BTreeMap<String, crate::omp::OmpConfiguration>;
14/// Type alias for grok configuration map
15type GrokConfigMap = BTreeMap<String, crate::grok::GrokConfiguration>;
16
17/// Storage mode for how configuration should be written to settings.json
18#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
19pub enum StorageMode {
20    /// Write to env field with uppercase environment variable names (default)
21    #[serde(rename = "env")]
22    #[default]
23    Env,
24    /// Write to root level with camelCase field names
25    #[serde(rename = "config")]
26    Config,
27}
28
29/// Represents a Claude API configuration
30///
31/// Contains the components needed to configure Claude API access:
32/// - alias_name: User-friendly identifier for the configuration
33/// - token: API authentication token
34/// - url: Base URL for the API endpoint
35/// - model: Optional custom model name
36/// - small_fast_model: Optional Haiku-class model for background tasks
37#[derive(Serialize, Deserialize, Default, Clone)]
38pub struct Configuration {
39    /// User-friendly alias name for this configuration
40    pub alias_name: String,
41    /// ANTHROPIC_AUTH_TOKEN value (API authentication token)
42    pub token: String,
43    /// ANTHROPIC_API_KEY value (alternative to AUTH_TOKEN, mutually exclusive)
44    #[serde(skip_serializing_if = "Option::is_none")]
45    pub api_key: Option<String>,
46    /// ANTHROPIC_BASE_URL value (API endpoint URL)
47    pub url: String,
48    /// ANTHROPIC_MODEL value (custom model name)
49    #[serde(skip_serializing_if = "Option::is_none")]
50    pub model: Option<String>,
51    /// ANTHROPIC_SMALL_FAST_MODEL value (Haiku-class model for background tasks)
52    #[serde(skip_serializing_if = "Option::is_none")]
53    pub small_fast_model: Option<String>,
54    /// ANTHROPIC_MAX_THINKING_TOKENS value (Maximum thinking tokens limit)
55    #[serde(skip_serializing_if = "Option::is_none")]
56    pub max_thinking_tokens: Option<u32>,
57    /// API timeout in milliseconds
58    #[serde(skip_serializing_if = "Option::is_none")]
59    pub api_timeout_ms: Option<u32>,
60    /// Disable non-essential traffic flag
61    #[serde(skip_serializing_if = "Option::is_none")]
62    pub claude_code_disable_nonessential_traffic: Option<u32>,
63    /// Default Sonnet model name
64    #[serde(skip_serializing_if = "Option::is_none")]
65    pub anthropic_default_sonnet_model: Option<String>,
66    /// Default Opus model name
67    #[serde(skip_serializing_if = "Option::is_none")]
68    pub anthropic_default_opus_model: Option<String>,
69    /// Default Haiku model name
70    #[serde(skip_serializing_if = "Option::is_none")]
71    pub anthropic_default_haiku_model: Option<String>,
72    /// Enable experimental agent teams flag
73    #[serde(skip_serializing_if = "Option::is_none")]
74    pub claude_code_experimental_agent_teams: Option<u32>,
75    /// Disable 1M context limit flag
76    #[serde(skip_serializing_if = "Option::is_none")]
77    pub claude_code_disable_1m_context: Option<u32>,
78    /// Subagent model name
79    #[serde(skip_serializing_if = "Option::is_none")]
80    pub claude_code_subagent_model: Option<String>,
81    /// Disable non-streaming fallback flag
82    #[serde(skip_serializing_if = "Option::is_none")]
83    pub claude_code_disable_nonstreaming_fallback: Option<u32>,
84    /// Effort level for Claude Code
85    #[serde(skip_serializing_if = "Option::is_none")]
86    pub claude_code_effort_level: Option<String>,
87    /// Disable prompt caching flag
88    #[serde(skip_serializing_if = "Option::is_none")]
89    pub disable_prompt_caching: Option<u32>,
90    /// Disable experimental betas flag
91    #[serde(skip_serializing_if = "Option::is_none")]
92    pub claude_code_disable_experimental_betas: Option<u32>,
93    /// Disable auto-updater flag
94    #[serde(skip_serializing_if = "Option::is_none")]
95    pub disable_autoupdater: Option<u32>,
96}
97
98impl Configuration {
99    /// Get all environment variable names that this configuration can set
100    ///
101    /// Returns a vector of all UPPERCASE environment variable names
102    /// that can be set by this configuration, used for conflict detection
103    /// in config mode.
104    pub fn get_env_field_names() -> Vec<&'static str> {
105        vec![
106            "ANTHROPIC_AUTH_TOKEN",
107            "ANTHROPIC_API_KEY",
108            "ANTHROPIC_BASE_URL",
109            "ANTHROPIC_MODEL",
110            "ANTHROPIC_SMALL_FAST_MODEL",
111            "ANTHROPIC_MAX_THINKING_TOKENS",
112            "API_TIMEOUT_MS",
113            "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC",
114            "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS",
115            "CLAUDE_CODE_DISABLE_1M_CONTEXT",
116            "CLAUDE_CODE_SUBAGENT_MODEL",
117            "CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK",
118            "CLAUDE_CODE_EFFORT_LEVEL",
119            "DISABLE_PROMPT_CACHING",
120            "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS",
121            "DISABLE_AUTOUPDATER",
122            "ANTHROPIC_DEFAULT_SONNET_MODEL",
123            "ANTHROPIC_DEFAULT_OPUS_MODEL",
124            "ANTHROPIC_DEFAULT_HAIKU_MODEL",
125        ]
126    }
127
128    /// Get the authentication credential and its environment variable name.
129    ///
130    /// Returns `("ANTHROPIC_API_KEY", key)` when `api_key` is set,
131    /// otherwise `("ANTHROPIC_AUTH_TOKEN", token)`.
132    pub fn auth_env_pair(&self) -> (&'static str, &str) {
133        if let Some(ref key) = self.api_key {
134            ("ANTHROPIC_API_KEY", key)
135        } else {
136            ("ANTHROPIC_AUTH_TOKEN", &self.token)
137        }
138    }
139
140    /// Get environment variable names that should be cleared in env mode
141    ///
142    /// Returns a vector of UPPERCASE environment variable names that are
143    /// configuration-specific and should be cleared from settings.json when
144    /// switching in env mode. User preference fields are excluded.
145    pub fn get_clearable_env_field_names() -> Vec<&'static str> {
146        vec![
147            "ANTHROPIC_AUTH_TOKEN",
148            "ANTHROPIC_API_KEY",
149            "ANTHROPIC_BASE_URL",
150            "ANTHROPIC_MODEL",
151            "ANTHROPIC_SMALL_FAST_MODEL",
152            "ANTHROPIC_MAX_THINKING_TOKENS",
153            "API_TIMEOUT_MS",
154            "ANTHROPIC_DEFAULT_SONNET_MODEL",
155            "ANTHROPIC_DEFAULT_OPUS_MODEL",
156            "ANTHROPIC_DEFAULT_HAIKU_MODEL",
157            "CLAUDE_CODE_SUBAGENT_MODEL",
158            "CLAUDE_CODE_EFFORT_LEVEL",
159            // User preference fields are NOT included:
160            // - CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC
161            // - CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS
162            // - CLAUDE_CODE_DISABLE_1M_CONTEXT
163            // - CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK
164            // - DISABLE_PROMPT_CACHING
165            // - CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS
166            // - DISABLE_AUTOUPDATER
167        ]
168    }
169}
170
171#[cfg(test)]
172mod tests {
173    use super::*;
174
175    #[test]
176    fn test_get_env_field_names() {
177        let fields = Configuration::get_env_field_names();
178
179        // Verify all expected fields are present
180        let expected_fields = vec![
181            "ANTHROPIC_AUTH_TOKEN",
182            "ANTHROPIC_API_KEY",
183            "ANTHROPIC_BASE_URL",
184            "ANTHROPIC_MODEL",
185            "ANTHROPIC_SMALL_FAST_MODEL",
186            "ANTHROPIC_MAX_THINKING_TOKENS",
187            "API_TIMEOUT_MS",
188            "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC",
189            "ANTHROPIC_DEFAULT_SONNET_MODEL",
190            "ANTHROPIC_DEFAULT_OPUS_MODEL",
191            "ANTHROPIC_DEFAULT_HAIKU_MODEL",
192            "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS",
193            "CLAUDE_CODE_DISABLE_1M_CONTEXT",
194            "CLAUDE_CODE_SUBAGENT_MODEL",
195            "CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK",
196            "CLAUDE_CODE_EFFORT_LEVEL",
197            "DISABLE_PROMPT_CACHING",
198            "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS",
199            "DISABLE_AUTOUPDATER",
200        ];
201
202        assert_eq!(
203            fields.len(),
204            expected_fields.len(),
205            "Should have exactly 19 fields"
206        );
207
208        for expected_field in expected_fields {
209            assert!(
210                fields.contains(&expected_field),
211                "Missing field: {}",
212                expected_field
213            );
214        }
215
216        // Verify all fields are uppercase
217        for field in &fields {
218            assert_eq!(
219                field,
220                &field.to_uppercase(),
221                "Field {} should be uppercase",
222                field
223            );
224        }
225    }
226
227    #[test]
228    fn test_get_clearable_env_field_names() {
229        let fields = Configuration::get_clearable_env_field_names();
230
231        // Verify clearable fields (excludes user preference fields)
232        let expected_fields = vec![
233            "ANTHROPIC_AUTH_TOKEN",
234            "ANTHROPIC_API_KEY",
235            "ANTHROPIC_BASE_URL",
236            "ANTHROPIC_MODEL",
237            "ANTHROPIC_SMALL_FAST_MODEL",
238            "ANTHROPIC_MAX_THINKING_TOKENS",
239            "API_TIMEOUT_MS",
240            "ANTHROPIC_DEFAULT_SONNET_MODEL",
241            "ANTHROPIC_DEFAULT_OPUS_MODEL",
242            "ANTHROPIC_DEFAULT_HAIKU_MODEL",
243            "CLAUDE_CODE_SUBAGENT_MODEL",
244            "CLAUDE_CODE_EFFORT_LEVEL",
245        ];
246
247        // User preference fields should NOT be in clearable list
248        let excluded_fields = vec![
249            "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC",
250            "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS",
251            "CLAUDE_CODE_DISABLE_1M_CONTEXT",
252            "CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK",
253            "DISABLE_PROMPT_CACHING",
254            "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS",
255            "DISABLE_AUTOUPDATER",
256        ];
257
258        assert_eq!(
259            fields.len(),
260            expected_fields.len(),
261            "Should have exactly 12 clearable fields"
262        );
263
264        for expected_field in expected_fields {
265            assert!(
266                fields.contains(&expected_field),
267                "Missing clearable field: {}",
268                expected_field
269            );
270        }
271
272        // Verify excluded fields are NOT present
273        for excluded_field in excluded_fields {
274            assert!(
275                !fields.contains(&excluded_field),
276                "User preference field {} should NOT be in clearable list",
277                excluded_field
278            );
279        }
280    }
281
282    #[test]
283    fn test_remove_anthropic_env_uses_dynamic_fields() {
284        let mut settings = ClaudeSettings::default();
285
286        // Add all possible environment variables
287        let env_fields = Configuration::get_env_field_names();
288        for field in &env_fields {
289            settings
290                .env
291                .insert(field.to_string(), "test_value".to_string());
292        }
293
294        // Add some other env variables that shouldn't be removed
295        settings
296            .env
297            .insert("OTHER_VAR".to_string(), "other_value".to_string());
298        settings
299            .env
300            .insert("CLAUDE_THEME".to_string(), "dark".to_string());
301
302        // Remove Anthropic environment variables
303        settings.remove_anthropic_env();
304
305        // Verify all Anthropic fields are removed
306        for field in &env_fields {
307            assert!(
308                !settings.env.contains_key(*field),
309                "Field {} should be removed",
310                field
311            );
312        }
313
314        // Verify other fields are preserved
315        assert!(
316            settings.env.contains_key("OTHER_VAR"),
317            "Other variables should be preserved"
318        );
319        assert!(
320            settings.env.contains_key("CLAUDE_THEME"),
321            "Other variables should be preserved"
322        );
323        assert_eq!(
324            settings.env.get("OTHER_VAR"),
325            Some(&"other_value".to_string())
326        );
327        assert_eq!(settings.env.get("CLAUDE_THEME"), Some(&"dark".to_string()));
328    }
329
330    #[test]
331    fn test_switch_to_config_uses_dynamic_fields() {
332        let mut settings = ClaudeSettings::default();
333
334        // Add all possible environment variables
335        let env_fields = Configuration::get_env_field_names();
336        for field in &env_fields {
337            settings
338                .env
339                .insert(field.to_string(), "old_value".to_string());
340        }
341
342        // Create a test configuration
343        let config = Configuration {
344            alias_name: "test".to_string(),
345            token: "new_token".to_string(),
346            api_key: None,
347            url: "https://api.new.com".to_string(),
348            model: Some("new_model".to_string()),
349            small_fast_model: Some("new_fast_model".to_string()),
350            max_thinking_tokens: Some(50000),
351            api_timeout_ms: Some(300000),
352            claude_code_disable_nonessential_traffic: Some(1),
353            anthropic_default_sonnet_model: Some("new_sonnet".to_string()),
354            anthropic_default_opus_model: Some("new_opus".to_string()),
355            anthropic_default_haiku_model: Some("new_haiku".to_string()),
356            claude_code_experimental_agent_teams: None,
357            claude_code_disable_1m_context: None,
358            claude_code_subagent_model: None,
359            claude_code_disable_nonstreaming_fallback: None,
360            claude_code_effort_level: None,
361            disable_prompt_caching: None,
362            claude_code_disable_experimental_betas: None,
363            disable_autoupdater: None,
364        };
365
366        // Switch to new configuration
367        settings.switch_to_config(&config);
368
369        // Verify the required fields are set correctly
370        assert_eq!(
371            settings.env.get("ANTHROPIC_AUTH_TOKEN"),
372            Some(&"new_token".to_string())
373        );
374        assert_eq!(
375            settings.env.get("ANTHROPIC_BASE_URL"),
376            Some(&"https://api.new.com".to_string())
377        );
378        assert_eq!(
379            settings.env.get("ANTHROPIC_MODEL"),
380            Some(&"new_model".to_string())
381        );
382        assert_eq!(
383            settings.env.get("ANTHROPIC_SMALL_FAST_MODEL"),
384            Some(&"new_fast_model".to_string())
385        );
386
387        // Verify additional fields are set correctly when provided in config
388        assert_eq!(
389            settings.env.get("ANTHROPIC_MAX_THINKING_TOKENS"),
390            Some(&"50000".to_string())
391        );
392        assert_eq!(
393            settings.env.get("API_TIMEOUT_MS"),
394            Some(&"300000".to_string())
395        );
396        assert_eq!(
397            settings.env.get("CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC"),
398            Some(&"1".to_string())
399        );
400        assert_eq!(
401            settings.env.get("ANTHROPIC_DEFAULT_SONNET_MODEL"),
402            Some(&"new_sonnet".to_string())
403        );
404        assert_eq!(
405            settings.env.get("ANTHROPIC_DEFAULT_OPUS_MODEL"),
406            Some(&"new_opus".to_string())
407        );
408        assert_eq!(
409            settings.env.get("ANTHROPIC_DEFAULT_HAIKU_MODEL"),
410            Some(&"new_haiku".to_string())
411        );
412    }
413
414    #[test]
415    fn test_switch_to_config_removes_optional_fields_when_not_provided() {
416        let mut settings = ClaudeSettings::default();
417
418        // Add all possible environment variables with old values
419        let env_fields = Configuration::get_env_field_names();
420        for field in &env_fields {
421            settings
422                .env
423                .insert(field.to_string(), "old_value".to_string());
424        }
425
426        // Create a test configuration without optional fields
427        let config = Configuration {
428            alias_name: "test".to_string(),
429            token: "new_token".to_string(),
430            api_key: None,
431            url: "https://api.new.com".to_string(),
432            model: Some("new_model".to_string()),
433            small_fast_model: Some("new_fast_model".to_string()),
434            max_thinking_tokens: None,
435            api_timeout_ms: None,
436            claude_code_disable_nonessential_traffic: None,
437            anthropic_default_sonnet_model: None,
438            anthropic_default_opus_model: None,
439            anthropic_default_haiku_model: None,
440            claude_code_experimental_agent_teams: None,
441            claude_code_disable_1m_context: None,
442            claude_code_subagent_model: None,
443            claude_code_disable_nonstreaming_fallback: None,
444            claude_code_effort_level: None,
445            disable_prompt_caching: None,
446            claude_code_disable_experimental_betas: None,
447            disable_autoupdater: None,
448        };
449
450        // Switch to new configuration
451        settings.switch_to_config(&config);
452
453        // Verify the required fields are set correctly
454        assert_eq!(
455            settings.env.get("ANTHROPIC_AUTH_TOKEN"),
456            Some(&"new_token".to_string())
457        );
458        assert_eq!(
459            settings.env.get("ANTHROPIC_BASE_URL"),
460            Some(&"https://api.new.com".to_string())
461        );
462        assert_eq!(
463            settings.env.get("ANTHROPIC_MODEL"),
464            Some(&"new_model".to_string())
465        );
466        assert_eq!(
467            settings.env.get("ANTHROPIC_SMALL_FAST_MODEL"),
468            Some(&"new_fast_model".to_string())
469        );
470
471        // Verify optional fields are removed when not provided in config
472        assert!(!settings.env.contains_key("ANTHROPIC_MAX_THINKING_TOKENS"));
473        assert!(!settings.env.contains_key("API_TIMEOUT_MS"));
474        assert!(
475            !settings
476                .env
477                .contains_key("CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC")
478        );
479        assert!(!settings.env.contains_key("ANTHROPIC_DEFAULT_SONNET_MODEL"));
480        assert!(!settings.env.contains_key("ANTHROPIC_DEFAULT_OPUS_MODEL"));
481        assert!(!settings.env.contains_key("ANTHROPIC_DEFAULT_HAIKU_MODEL"));
482        assert!(!settings.env.contains_key("CLAUDE_CODE_SUBAGENT_MODEL"));
483        assert!(
484            !settings
485                .env
486                .contains_key("CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK")
487        );
488        assert!(!settings.env.contains_key("CLAUDE_CODE_EFFORT_LEVEL"));
489        assert!(!settings.env.contains_key("DISABLE_PROMPT_CACHING"));
490        assert!(
491            !settings
492                .env
493                .contains_key("CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS")
494        );
495        assert!(!settings.env.contains_key("DISABLE_AUTOUPDATER"));
496    }
497}
498
499/// Storage manager for Claude API configurations
500///
501/// Handles persistence and retrieval of multiple API configurations
502/// stored in `~/.cc_auto_switch/configurations.json`
503#[derive(Serialize, Deserialize, Default)]
504pub struct ConfigStorage {
505    /// Map of alias names to configuration objects
506    pub configurations: ConfigMap,
507    /// Custom directory for Claude settings (optional)
508    pub claude_settings_dir: Option<String>,
509    /// Default storage mode for writing configurations (None = use env mode)
510    #[serde(skip_serializing_if = "Option::is_none")]
511    pub default_storage_mode: Option<StorageMode>,
512    /// Codex (OpenAI) configurations, stored separately from Claude configurations
513    #[serde(skip_serializing_if = "Option::is_none")]
514    pub codex_configurations: Option<CodexConfigMap>,
515    /// OMP configurations, stored separately from Claude configurations
516    #[serde(skip_serializing_if = "Option::is_none")]
517    pub omp_configurations: Option<OmpConfigMap>,
518    /// grok configurations, stored separately from Claude configurations
519    #[serde(skip_serializing_if = "Option::is_none")]
520    pub grok_configurations: Option<GrokConfigMap>,
521}
522
523/// Claude settings manager for API configuration
524///
525/// Manages the Claude settings.json file to control Claude's API configuration
526/// Handles environment variables and preserves other settings
527#[derive(Default, Clone)]
528#[allow(dead_code)]
529pub struct ClaudeSettings {
530    /// Environment variables map (ANTHROPIC_AUTH_TOKEN, ANTHROPIC_BASE_URL, ANTHROPIC_MODEL, ANTHROPIC_SMALL_FAST_MODEL)
531    pub env: EnvMap,
532    /// Other settings to preserve when modifying API configuration
533    pub other: JsonMap,
534}
535
536impl Serialize for ClaudeSettings {
537    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
538    where
539        S: Serializer,
540    {
541        use serde::ser::SerializeMap;
542
543        let mut map = serializer.serialize_map(Some(
544            self.other.len() + if self.env.is_empty() { 0 } else { 1 },
545        ))?;
546
547        // Serialize env field only if it has content
548        if !self.env.is_empty() {
549            map.serialize_entry("env", &self.env)?;
550        }
551
552        // Serialize other fields
553        for (key, value) in &self.other {
554            map.serialize_entry(key, value)?;
555        }
556
557        map.end()
558    }
559}
560
561impl<'de> Deserialize<'de> for ClaudeSettings {
562    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
563    where
564        D: Deserializer<'de>,
565    {
566        #[derive(Deserialize)]
567        struct ClaudeSettingsHelper {
568            #[serde(default)]
569            env: EnvMap,
570            #[serde(flatten)]
571            other: JsonMap,
572        }
573
574        let helper = ClaudeSettingsHelper::deserialize(deserializer)?;
575        Ok(ClaudeSettings {
576            env: helper.env,
577            other: helper.other,
578        })
579    }
580}
581
582/// Parameters for adding a new configuration
583#[allow(dead_code)]
584pub struct AddCommandParams {
585    pub alias_name: String,
586    pub token: Option<String>,
587    pub api_key: Option<String>,
588    pub url: Option<String>,
589    pub model: Option<String>,
590    pub small_fast_model: Option<String>,
591    pub max_thinking_tokens: Option<u32>,
592    pub api_timeout_ms: Option<u32>,
593    pub claude_code_disable_nonessential_traffic: Option<u32>,
594    pub anthropic_default_sonnet_model: Option<String>,
595    pub anthropic_default_opus_model: Option<String>,
596    pub anthropic_default_haiku_model: Option<String>,
597    pub claude_code_subagent_model: Option<String>,
598    pub claude_code_disable_nonstreaming_fallback: Option<u32>,
599    pub claude_code_effort_level: Option<String>,
600    pub disable_prompt_caching: Option<u32>,
601    pub claude_code_disable_experimental_betas: Option<u32>,
602    pub disable_autoupdater: Option<u32>,
603    pub force: bool,
604    pub interactive: bool,
605    pub token_arg: Option<String>,
606    pub url_arg: Option<String>,
607    pub from_file: Option<String>,
608}