> ## Documentation Index
> Fetch the complete documentation index at: https://docs.dodopayments.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Rust

> अपनी Rust एप्लिकेशनों में Dodo Payments को एकीकृत करें एक async-प्रथम, सख्ती से टाइप किए गए SDK के साथ जो Tokio और reqwest पर आधारित है।

Rust SDK Rust में लिखी गई एप्लिकेशनों से Dodo Payments REST API तक सुविधाजनक, async-प्रथम पहुँच प्रदान करता है। यह सख्ती से टाइप की गई अनुरोध और प्रतिक्रियाएँ, निर्मित पृष्ठांकन हेल्पर्स, और कॉन्फ़िगरेबल टाइमआउट्स और पर्यावरण प्रदान करता है।

## इंस्टालेशन

Cargo के साथ अपने प्रोजेक्ट में SDK जोड़ें:

```bash theme={null}
cargo add dodopayments
```

या इसे अपने `Cargo.toml` में मैन्युअल रूप से जोड़ें:

```toml theme={null}
[dependencies]
dodopayments = "1.106.0"
tokio = { version = "1", features = ["full"] }
serde_json = "1"
futures = "0.3" # required for streaming paginated results
```

<Info>
  SDK को Rust 1.75 या बाद के संस्करण की आवश्यकता होती है, जो इष्टतम प्रदर्शन के लिए आधुनिक async सुविधाओं का लाभ उठाता है।
</Info>

## त्वरित प्रारंभ

क्लाइंट डिफ़ॉल्ट रूप से आपका API कुंजी `DODO_PAYMENTS_API_KEY` परिवेश वेरिएबल से पढ़ता है। क्लाइंट को प्रारंभ करें और अपनी पहली चेकआउट सेशन बनाएँ:

```rust theme={null}
use dodopayments::Client;

#[tokio::main]
async fn main() -> dodopayments::Result<()> {
    let client = Client::from_env()?;

    let result = client
        .checkout_sessions()
        .create()
        .body(dodopayments::models::CheckoutSessionsCreateParams {
            product_cart: Some(vec![dodopayments::models::ProductItemReq {
                product_id: "product_id".to_string(),
                quantity: 1,
                addons: None,
                amount: None,
                credit_entitlements: None,
            }]),
            ..Default::default()
        })
        .await?;

    println!("{result:?}");
    Ok(())
}
```

<Warning>
  अपने API कुंजी को हमेशा सुरक्षित रूप से परिवेश वेरिएबल्स का उपयोग करके स्टोर करें। कभी भी इसे अपने स्रोत कोड में हार्ड कोड न करें।
</Warning>

## मुख्य विशेषताएं

<CardGroup cols={2}>
  <Card title="Async First" icon="bolt">
    Tokio और reqwest पर आधारित कई समर्थन के साथ
  </Card>

  <Card title="Strong Typing" icon="shield-check">
    कंपाइल-टाइम सुरक्षा के लिए सख्ती से टाइप की गई अनुरोध और प्रतिक्रियाएँ
  </Card>

  <Card title="Auto-Pagination" icon="layer-group">
    पृष्ठों में हर आइटम को स्ट्रीम करें या एक समय में एक पृष्ठ को आगे बढ़ाएँ
  </Card>

  <Card title="Configurable" icon="sliders">
    पर्यावरण, टाइमआउट्स, और बेस URL को प्रति क्लाइंट कॉन्फ़िगर करें
  </Card>
</CardGroup>

## कॉन्फ़िगरेशन

### पर्यावरण वेरिएबल्स

डिफ़ॉल्ट रूप से, `Client::from_env()` आपके API कुंजी को `DODO_PAYMENTS_API_KEY` परिवेश वेरिएबल से पढ़ता है और डिफ़ॉल्ट बेस URL का उपयोग करता है जब तक कि आप `DODO_PAYMENTS_BASE_URL` सेट नहीं करते:

```bash theme={null}
export DODO_PAYMENTS_API_KEY="your_api_key"
export DODO_PAYMENTS_BASE_URL="https://test.dodopayments.com" # optional
```

आप क्लाइंट को स्पष्ट रूप से भी कॉन्फ़िगर कर सकते हैं। `Client::new` एक `Result` लौटाता है, इसलिए इसे `?` के साथ अनलॉक करें जो एक `dodopayments::Result` लौटाता है:

```rust theme={null}
use dodopayments::{Client, ClientConfig};

#[tokio::main]
async fn main() -> dodopayments::Result<()> {
    let client = Client::new(
        ClientConfig::new("https://live.dodopayments.com").with_api_key("My API Key"),
    )?;
    println!("{}", client.base_url());
    Ok(())
}
```

### पर्यावरण

| नाम         | आधार URL                        |
| ----------- | ------------------------------- |
| `live_mode` | `https://live.dodopayments.com` |
| `test_mode` | `https://test.dodopayments.com` |

डिफ़ॉल्ट आधार URL `https://live.dodopayments.com` है। URLs को हार्ड-कोड करने के बजाय, `Environment` एनम का उपयोग करके किसी और पर्यावरण का चयन करें:

```rust theme={null}
use dodopayments::{Client, ClientConfig, Environment};

let client = Client::new(
    ClientConfig::from_environment(Environment::TestMode).with_api_key("My API Key"),
)?;
```

एक गैर-डिफ़ॉल्ट पर्यावरण को लक्ष्य करने के दौरान `DODO_PAYMENTS_API_KEY` से API कुंजी की रीडिंग जारी रखने के लिए, इसे विन्यास में ओवरराइड करें:

```rust theme={null}
use dodopayments::{Client, ClientConfig, Environment};

let client = Client::new(ClientConfig::from_env()?.with_environment(Environment::TestMode))?;
```

### टाइमआउट्स

डिफ़ॉल्ट अनुरोध समय समाप्ति 30 सेकंड है। इसे प्रति क्लाइंट ओवरराइड करें:

```rust theme={null}
use std::time::Duration;
use dodopayments::{Client, ClientConfig};

let client = Client::new(
    ClientConfig::new("https://live.dodopayments.com")
        .with_api_key("My API Key")
        .with_timeout(Duration::from_secs(60)),
)?;
```

## सामान्य संचालन

### एक चेकआउट सत्र बनाएँ

एक चेकआउट सत्र उत्पन्न करें:

```rust theme={null}
let session = client
    .checkout_sessions()
    .create()
    .body(dodopayments::models::CheckoutSessionsCreateParams {
        product_cart: Some(vec![dodopayments::models::ProductItemReq {
            product_id: "prod_123".to_string(),
            quantity: 1,
            addons: None,
            amount: None,
            credit_entitlements: None,
        }]),
        return_url: Some("https://yourdomain.com/return".to_string()),
        ..Default::default()
    })
    .await?;

println!("{session:?}");
```

### ग्राहकों को प्रबंधित करें

ग्राहक जानकारी बनाएं और पुनः प्राप्त करें:

```rust theme={null}
// Create a customer
let customer = client
    .customers()
    .create()
    .body(dodopayments::models::CustomerCreateParams {
        email: "customer@example.com".to_string(),
        name: "John Doe".to_string(),
        ..Default::default()
    })
    .await?;

// Retrieve a customer
let customer = client
    .customers()
    .retrieve("cus_123")
    .await?;

println!("{customer:?}");
```

### सब्सक्रिप्शन्स को संभालें

आवर्ती सब्सक्रिप्शन्स बनाएँ और प्रबंधित करें:

```rust theme={null}
let subscription = client
    .subscriptions()
    .create()
    .body(dodopayments::models::SubscriptionCreateParams {
        billing: dodopayments::models::BillingAddress {
            country: "US".to_string(),
            city: "San Francisco".to_string(),
            state: "CA".to_string(),
            street: "1 Market St".to_string(),
            zipcode: "94105".to_string(),
        },
        customer: dodopayments::models::CustomerRequest::AttachExisting(
            dodopayments::models::AttachExistingCustomer {
                customer_id: "cus_123".to_string(),
            },
        ),
        product_id: "pdt_456".to_string(),
        quantity: 1,
        ..Default::default()
    })
    .await?;

println!("{subscription:?}");
```

<Info>
  `billing` के लिए कम से कम दो-अक्षर का ISO `country` कोड जरूरी है। `customer` एक `CustomerRequest` एनम है - एक मौजूदा ग्राहक के लिए `AttachExisting` पास करें या एक नए के लिए `New`। राशि क्षेत्रों, जैसे `product_price` को न्यूनतम मुद्रा विभाजन में रखें (उदाहरण: `2500` = \$25.00 USD)।
</Info>

## उपयोग-आधारित बिलिंग

### उपयोग घटनाएँ इनजेस्ट करें

कस्टम इवेंट ट्रैक करें:

```rust theme={null}
let response = client
    .usage_events()
    .ingest()
    .body(dodopayments::models::UsageEventsIngestParams {
        events: vec![dodopayments::models::EventInput {
            event_id: "api_call_12345".to_string(),
            customer_id: "cus_abc123".to_string(),
            event_name: "api_request".to_string(),
            ..Default::default()
        }],
    })
    .await?;

println!("{response:?}");
```

### उपयोग घटनाएँ सूचीबद्ध करें

```rust theme={null}
let events = client
    .usage_events()
    .list()
    .query(serde_json::json!({
        "customer_id": "cus_abc123",
        "event_name": "api_request",
    }))
    .await?;

for event in &events.items {
    println!("{event:?}");
}
```

## पृष्ठांकन

सूची अंत बिंदु एक टाइप की गई पृष्ठ लौटाते हैं जिसकी `items` फ़ील्ड वर्तमान परिणामों के पृष्ठ को रखती है। हर पृष्ठ के पार प्रत्येक आइटम को स्ट्रीम करें `into_stream` के साथ:

```rust theme={null}
use futures::StreamExt;

let mut items = Box::pin(
    client
        .payments()
        .list()
        .query(serde_json::json!({}))
        .await?
        .into_stream(),
);

while let Some(item) = items.next().await {
    let item = item?;
    println!("{item:?}");
}
```

या एक समय में एक पृष्ठ आगे बढ़ाएं `get_next_page` के साथ:

```rust theme={null}
let mut page = client
    .payments()
    .list()
    .query(serde_json::json!({}))
    .await?;

loop {
    for item in &page.items {
        println!("{item:?}");
    }
    match page.get_next_page().await? {
        Some(next) => page = next,
        None => break,
    }
}
```

## त्रुटि हैंडलिंग

प्रत्येक विधि एक `dodopayments::Result<T>` लौटाती है। असफलताओं का प्रतिनिधित्व `dodopayments::Error` एनम द्वारा किया जाता है। इसे हैंडल करने के लिए API त्रुटियों को ट्रांसपोर्ट त्रुटियों से अलग से मिलाएँ:

```rust theme={null}
let result = client
    .checkout_sessions()
    .create()
    .body(dodopayments::models::CheckoutSessionsCreateParams {
        product_cart: Some(vec![dodopayments::models::ProductItemReq {
            product_id: "product_id".to_string(),
            quantity: 1,
            addons: None,
            amount: None,
            credit_entitlements: None,
        }]),
        ..Default::default()
    })
    .await;

match result {
    Ok(value) => println!("{value:?}"),
    Err(dodopayments::Error::Api { status, message }) => {
        eprintln!("API returned {status}: {message}");
    }
    Err(err) => eprintln!("request failed: {err}"),
}
```

## अप्रलेखित अंत बिंदु

किसी अंत बिंदु को कॉल करने के लिए जो अभी तक टाइप की गई विधि के रूप में उजागर नहीं किया गया है, निम्न-स्तरीय `request` बिल्डर का उपयोग करें, जो प्रमाणीकरण और आधार URL लागू करता है:

```rust theme={null}
let response = client
    .request(reqwest::Method::GET, "/some/path")
    .send()
    .await?;
```

## संसाधन

<CardGroup cols={2}>
  <Card title="GitHub Repository" icon="github" href="https://github.com/dodopayments/dodopayments-rust">
    स्रोत कोड देखें और योगदान करें
  </Card>

  <Card title="Crates.io" icon="cube" href="https://crates.io/crates/dodopayments">
    प्रकाशित क्रेट और संस्करण देखें
  </Card>

  <Card title="API Reference" icon="book" href="/api-reference/introduction">
    पूर्ण API दस्तावेज़ीकरण
  </Card>

  <Card title="Discord Community" icon="discord" href="https://discord.gg/bYqAp4ayYh">
    सहायता प्राप्त करें और डेवलपर्स के साथ जुड़ें
  </Card>
</CardGroup>

## सहायता

Rust SDK के साथ मदद की जरूरत है?

* **Discord**: वास्तविक समय समर्थन के लिए हमारे [समुदाय सर्वर](https://discord.gg/bYqAp4ayYh) से जुड़ें
* **Email**: हमसे संपर्क करें [support@dodopayments.com](mailto:support@dodopayments.com) पर
* **GitHub**: [repository](https://github.com/dodopayments/dodopayments-rust/issues) पर एक मुद्दा खोलें

## योगदान

हम योगदान का स्वागत करते हैं! आरंभ करने के लिए [योगदान दिशानिर्देश](https://github.com/dodopayments/dodopayments-rust/blob/main/CONTRIBUTING.md) देखें।