from callx import Client

# Initialize the client
callx = Client(api_key='YOUR_API_KEY')

# Send a message
def send_message():
    try:
        message = callx.messages.send(
            conversation_id=123,
            content='Hello from the CallX API!',
            content_type='text'
        )
        
        print(f'Message sent: {message.id}')
    except Exception as e:
        print(f'Error sending message: {e}')

send_message()

import com.callx.Client;
import com.callx.models.Message;
import com.callx.requests.SendMessageRequest;

public class SendMessageExample {
    public static void main(String[] args) {
        // Initialize the client
        Client callx = new Client.Builder()
            .apiKey("YOUR_API_KEY")
            .build();
        
        // Send a message
        try {
            SendMessageRequest request = new SendMessageRequest.Builder()
                .conversationId(123)
                .content("Hello from the CallX API!")
                .contentType("text")
                .build();
                
            Message message = callx.messages().send(request);
            System.out.println("Message sent: " + message.getId());
        } catch (Exception e) {
            System.err.println("Error sending message: " + e.getMessage());
        }
    }
}

using CallX;
using CallX.Models;
using System;
using System.Threading.Tasks;

namespace CallXExample
{
    class Program
    {
        static async Task Main(string[] args)
        {
            // Initialize the client
            var callx = new CallXClient("YOUR_API_KEY");
            
            // Send a message
            try
            {
                var message = await callx.Messages.SendAsync(new SendMessageRequest
                {
                    ConversationId = 123,
                    Content = "Hello from the CallX API!",
                    ContentType = "text"
                });
                
                Console.WriteLine($"Message sent: {message.Id}");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error sending message: {ex.Message}");
            }
        }
    }
}

package main

import (
        "fmt"
        "log"

        callx "github.com/callx/callx-sdk-go"
)

func main() {
        // Initialize the client
        client := callx.NewClient("YOUR_API_KEY")

        // Send a message
        message, err := client.Messages.Send(&callx.SendMessageParams{
                ConversationID: 123,
                Content:        "Hello from the CallX API!",
                ContentType:    "text",
        })

        if err != nil {
                log.Fatalf("Error sending message: %v", err)
        }

        fmt.Printf("Message sent: %d\n", message.ID)
}

require 'callx'

# Initialize the client
callx = CallX::Client.new(api_key: 'YOUR_API_KEY')

# Send a message
begin
  message = callx.messages.send(
    conversation_id: 123,
    content: 'Hello from the CallX API!',
    content_type: 'text'
  )
  
  puts "Message sent: #{message.id}"
rescue CallX::Error => e
  puts "Error sending message: #{e.message}"
end

<?php

require_once 'vendor/autoload.php';

use CallX\Client;
use CallX\Exception\ApiException;

// Initialize the client
$callx = new Client('YOUR_API_KEY');

// Send a message
try {
    $message = $callx->messages->send([
        'conversation_id' => 123,
        'content' => 'Hello from the CallX API!',
        'content_type' => 'text'
    ]);
    
    echo "Message sent: {$message->id}\n";
} catch (ApiException $e) {
    echo "Error sending message: {$e->getMessage()}\n";
}

import CallXSDK

// Initialize the client
let callx = CallX(apiKey: "YOUR_API_KEY")

// Send a message
let request = SendMessageRequest(
    conversationId: 123,
    content: "Hello from the CallX API!",
    contentType: "text"
)

callx.messages.send(request) { result in
    switch result {
    case .success(let message):
        print("Message sent: \(message.id)")
    case .failure(let error):
        print("Error sending message: \(error.localizedDescription)")
    }
}

import com.callx.CallXClient
import com.callx.models.SendMessageRequest
import kotlinx.coroutines.runBlocking

fun main() = runBlocking {
    // Initialize the client
    val callx = CallXClient("YOUR_API_KEY")
    
    // Send a message
    try {
        val message = callx.messages.send(
            SendMessageRequest(
                conversationId = 123,
                content = "Hello from the CallX API!",
                contentType = "text"
            )
        )
        
        println("Message sent: ${message.id}")
    } catch (e: Exception) {
        println("Error sending message: ${e.message}")
    }
}

use callx::{Client, SendMessageRequest, Error};

#[tokio::main]
async fn main() -> Result<(), Error> {
    // Initialize the client
    let callx = Client::new("YOUR_API_KEY");
    
    // Send a message
    let message = callx.messages()
        .send(SendMessageRequest {
            conversation_id: 123,
            content: "Hello from the CallX API!".to_string(),
            content_type: Some("text".to_string()),
            metadata: None,
        })
        .await?;
    
    println!("Message sent: {}", message.id);
    
    Ok(())
}