{
  "id": "ext-patient-001",
  "uhid": 12345,
  "uhidPrefix": "ZAI",
  "fullName": "John Doe",
  "title": "Mr.",
  "dateOfBirth": "1990-05-15",
  "email": "john.doe@email.com",
  "gender": "Male",
  "phoneNumber": "+1234567890",
  "bloodGroup": "O+",
  "aadhaarNumber": "123456789012",
  "whatsappNumber": "+1234567890",
  "preferred_lang": "en",
  "address": "123 Healthcare St, Medical City, MC 12345",
  "emergencyContactName": "Jane Doe",
  "emergencyContactRelation": "Spouse",
  "emergencyContactPhone": "+1234567891",
  "insuranceProvider": "Health Insurance Co",
  "insurancePolicyNumber": "POL123456",
  "medicalHistory": "Diabetes, Hypertension",
  "remarks": "Regular checkup patient",
  "isTeleCommunication": false,
  "visited": false,
  "referredBy": "Dr. Smith"
}

{
  "status": "success",
  "message": "Patient created successfully",
  "data": {
    "id": "internal-uuid-123",
    "externalId": "ext-patient-001",
    "fullName": "John Doe",
    "uhid": 12345,
    "createdAt": "2024-01-15T10:30:00Z"
  }
}

GET /zauto-api/patients?page=1&limit=20&search=john
Authorization: Bearer <token>

{
  "id": "ext-visit-001",
  "patientId": "ext-patient-001",
  "visitDateTime": "2024-01-15T14:30:00Z",
  "tokenNumber": 45,
  "providerId": "ext-provider-001",
  "patientType": "OUT_PATIENT",
  "dischargeDateTime": "2024-01-15T16:30:00Z",
  "purposeOfVisit": "Regular checkup and blood pressure monitoring",
  "status": "IN_QUEUE"
}

POST /zauto-api/specialities
GET  /zauto-api/specialities?page=1&limit=10&search=cardio
GET  /zauto-api/specialities/{id}
PUT  /zauto-api/specialities/{id}
DELETE /zauto-api/specialities/{id}

const axios = require('axios');

class ZautoAIClient {
  constructor(clientId, clientSecret, baseUrl = 'https://api.zautoai.com') {
    this.clientId = clientId;
    this.clientSecret = clientSecret;
    this.baseUrl = baseUrl;
    this.accessToken = null;
    this.refreshToken = null;
  }

  async authenticate() {
    try {
      const response = await axios.post(`${this.baseUrl}/api/auth/oAuth/token`, {
        grant_type: 'client_credentials',
        client_id: this.clientId,
        client_secret: this.clientSecret
      });

      this.accessToken = response.data.access_token;
      this.refreshToken = response.data.refresh_token;
      
      // Set token expiration timer
      setTimeout(() => {
        this.refreshAccessToken();
      }, (response.data.expires_in - 60) * 1000);

      return response.data;
    } catch (error) {
      throw new Error(`Authentication failed: ${error.response?.data?.error_description || error.message}`);
    }
  }

  getHeaders() {
    return {
      'Authorization': `Bearer ${this.accessToken}`,
      'Content-Type': 'application/json'
    };
  }

  async createPatient(patientData) {
    const response = await axios.post(
      `${this.baseUrl}/zauto-api/patients`,
      patientData,
      { headers: this.getHeaders() }
    );
    return response.data;
  }

  async getPatients(page = 1, limit = 10, search = '') {
    const params = new URLSearchParams({ page, limit, search });
    const response = await axios.get(
      `${this.baseUrl}/zauto-api/patients?${params}`,
      { headers: this.getHeaders() }
    );
    return response.data;
  }

  async createPatientVisit(visitData) {
    const response = await axios.post(
      `${this.baseUrl}/zauto-api/patient-visits`,
      visitData,
      { headers: this.getHeaders() }
    );
    return response.data;
  }
}

// Usage example
async function main() {
  const client = new ZautoAIClient(
    'zauto_hospital_a1b2c3d4',
    'zauto_1234567890abcdef...'
  );

  try {
    // Authenticate
    await client.authenticate();
    console.log('Authentication successful');

    // Create a patient
    const patientData = {
      id: 'ext-patient-12345',
      uhid: 98765,
      fullName: 'Alice Johnson',
      phoneNumber: '+1234567890',
      email: 'alice.johnson@email.com',
      gender: 'Female'
    };

    const createResponse = await client.createPatient(patientData);
    console.log('Patient created:', createResponse.data);

    // Create a patient visit
    const visitData = {
      id: 'ext-visit-67890',
      patientId: 'ext-patient-12345',
      visitDateTime: new Date().toISOString(),
      purposeOfVisit: 'Annual checkup',
      patientType: 'OUT_PATIENT'
    };

    const visitResponse = await client.createPatientVisit(visitData);
    console.log('Visit created:', visitResponse.data);

  } catch (error) {
    console.error('Error:', error.message);
  }
}

main();

import requests
import json
from datetime import datetime

class ZautoAIClient:
    def __init__(self, client_id, client_secret, base_url="https://api.zautoai.com"):
        self.client_id = client_id
        self.client_secret = client_secret
        self.base_url = base_url
        self.access_token = None
        self.refresh_token = None

    def authenticate(self):
        url = f"{self.base_url}/api/auth/oAuth/token"
        data = {
            "grant_type": "client_credentials",
            "client_id": self.client_id,
            "client_secret": self.client_secret
        }
        
        response = requests.post(url, json=data)
        response.raise_for_status()
        
        token_data = response.json()
        self.access_token = token_data["access_token"]
        self.refresh_token = token_data["refresh_token"]
        
        return token_data

    def get_headers(self):
        return {
            "Authorization": f"Bearer {self.access_token}",
            "Content-Type": "application/json"
        }

    def create_patient(self, patient_data):
        url = f"{self.base_url}/zauto-api/patients"
        response = requests.post(url, json=patient_data, headers=self.get_headers())
        response.raise_for_status()
        return response.json()

    def get_patients(self, page=1, limit=10, search=""):
        url = f"{self.base_url}/zauto-api/patients"
        params = {"page": page, "limit": limit, "search": search}
        response = requests.get(url, params=params, headers=self.get_headers())
        response.raise_for_status()
        return response.json()

# Usage
client = ZautoAIClient("zauto_hospital_a1b2c3d4", "zauto_1234567890abcdef...")
client.authenticate()

# Create patient
patient = {
    "id": "ext-patient-54321",
    "uhid": 11111,
    "fullName": "Bob Wilson",
    "phoneNumber": "+1987654321",
    "gender": "Male"
}

result = client.create_patient(patient)
print(f"Patient created: {result['data']['externalId']}")

# Authentication
$authBody = @{
    grant_type = "client_credentials"
    client_id = "zauto_hospital_a1b2c3d4"
    client_secret = "zauto_1234567890abcdef..."
} | ConvertTo-Json

$authResponse = Invoke-RestMethod -Method Post -Uri "https://api.zautoai.com/api/auth/oAuth/token" -Body $authBody -ContentType "application/json"
$token = $authResponse.access_token

# Create patient
$headers = @{
    "Authorization" = "Bearer $token"
    "Content-Type" = "application/json"
}

$patientData = @{
    id = "ext-patient-99999"
    uhid = 55555
    fullName = "Charlie Brown"
    phoneNumber = "+1555123456"
    email = "charlie.brown@email.com"
} | ConvertTo-Json

$patientResponse = Invoke-RestMethod -Method Post -Uri "https://api.zautoai.com/zauto-api/patients" -Headers $headers -Body $patientData

Write-Host "Patient created: $($patientResponse.data.externalId)"

{
  "id": "test-patient-001",
  "uhid": 99999,
  "fullName": "Test Patient",
  "phoneNumber": "+1234567890",
  "email": "test@example.com"
}

{
  "id": "test-provider-001",
  "fullName": "Dr. Test Provider",
  "email": "testprovider@example.com"
}

{
  "id": "test-visit-001",
  "patientId": "test-patient-001",
  "visitDateTime": "2024-01-15T14:30:00Z",
  "purposeOfVisit": "Test visit"
}