aves-sdk 1.0.3 → 1.1.1

package/README.md

@@ -1,19 +1,15 @@
-# AVES SDK for NestJS
+# Aves SDK
 
-A comprehensive TypeScript SDK for integrating with the AVES XML REST API in NestJS applications. This SDK provides full type safety, validation, error handling, and follows NestJS best practices.
+TypeScript SDK for integrating with the Aves XML 1.8.0 Booking API in NestJS applications. 100% type-safe, fully validated, and compliant with the official Aves XML specification.
 
 ## Features
 
-- **Full NestJS Integration** - Native module with `forRoot`/`forRootAsync` support and global availability
-- **Complete Type Safety** - Comprehensive TypeScript interfaces with clean API abstractions
-- **Advanced Validation** - Modern Zod validation with `AvesValidator` class and utility functions
-- **Enhanced Date Handling** - Native JavaScript Date integration for robust date manipulation and validation
-- **Error Handling** - Structured error handling with AVES-specific error codes
-- **Configuration** - Environment-based configuration with validation
-- **Dependency Injection** - Interface-based DI following NestJS patterns
-- **Clean APIs** - Developer-friendly interfaces abstracting XML complexity
-- **Bidirectional Mappers** - Seamless conversion between clean and XML interfaces
-- **Production Ready** - Built for npm deployment with proper exports
+- **100% Aves XML 1.8.0 Compliant** - Exact implementation of official spec
+- **Full Type Safety** - Discriminated unions, type narrowing, zero `any` types
+- **Smart Interfaces** - Type-safe search with discriminated unions
+- **Zod Validation** - Runtime validation for all requests/responses
+- **NestJS Native** - Proper module with DI support
+- **Production Ready** - Tested, validated, optimized bundle
 
 ## Installation
 
@@ -29,48 +25,32 @@ bun add aves-sdk
 
 ## Quick Start
 
-### 1. Environment Configuration
-
-Create a `.env` file:
+### 1. Configure Environment
 
 ```env
-AVES_BASE_URL=https://api.aves.example.com
+AVES_BASE_URL=https://your-aves-instance.com
 AVES_HOST_ID=123456
-AVES_XTOKEN=your_xtoken_here
+AVES_XTOKEN=your_token_here
 AVES_LANGUAGE_CODE=01
-AVES_TIMEOUT=30000
 ```
 
-### 2. Module Setup
+### 2. Import Module
 
 ```typescript
 import { Module } from '@nestjs/common';
-import { ConfigModule } from '@nestjs/config';
+import { ConfigModule, ConfigService } from '@nestjs/config';
 import { AvesModule } from 'aves-sdk';
 
 @Module({
   imports: [
-    ConfigModule.forRoot({
-      isGlobal: true,
-    }),
-    // Synchronous configuration
-    AvesModule.forRoot({
-      baseUrl: process.env.AVES_BASE_URL!,
-      hostId: process.env.AVES_HOST_ID!,
-      xtoken: process.env.AVES_XTOKEN!,
-      languageCode: process.env.AVES_LANGUAGE_CODE,
-      timeout: parseInt(process.env.AVES_TIMEOUT || '30000'),
-    }),
-
-    // OR Asynchronous configuration
+    ConfigModule.forRoot({ isGlobal: true }),
     AvesModule.forRootAsync({
       imports: [ConfigModule],
-      useFactory: (configService: ConfigService) => ({
-        baseUrl: configService.get('AVES_BASE_URL')!,
-        hostId: configService.get('AVES_HOST_ID')!,
-        xtoken: configService.get('AVES_XTOKEN')!,
-        languageCode: configService.get('AVES_LANGUAGE_CODE'),
-        timeout: configService.get('AVES_TIMEOUT'),
+      useFactory: (config: ConfigService) => ({
+        baseUrl: config.get('AVES_BASE_URL')!,
+        hostId: config.get('AVES_HOST_ID')!,
+        xtoken: config.get('AVES_XTOKEN')!,
+        languageCode: config.get('AVES_LANGUAGE_CODE'),
       }),
       inject: [ConfigService],
     }),
@@ -79,623 +59,350 @@ import { AvesModule } from 'aves-sdk';
 export class AppModule {}
 ```
 
-### 3. Service Usage with Clean APIs
+### 3. Use the Service
 
 ```typescript
 import { Injectable } from '@nestjs/common';
-import {
-  AvesService,
-  SearchCustomerRequest,
-  CreateBookingRequest,
-  Customer,
-  BookingResponse,
-} from 'aves-sdk';
+import { AvesService, SearchCustomerRequest } from 'aves-sdk';
 
 @Injectable()
 export class BookingService {
-  constructor(private readonly avesService: AvesService) {}
-
-  async searchCustomers(searchTerm: string): Promise<Customer[]> {
-    const searchRequest: SearchCustomerRequest = {
-      type: 'customer',
-      fields: [
-        {
-          name: 'LastName',
-          value: searchTerm,
-          operator: 'contains',
-        },
-      ],
+  constructor(private readonly aves: AvesService) {}
+
+  async findCustomer(code: string) {
+    // Type-safe discriminated union
+    const request: SearchCustomerRequest = {
+      type: 'code',
+      code: code,
+      pagination: { pages: 50, page: 1 },
     };
 
-    const response = await this.avesService.searchCustomer(searchRequest);
-    return response.results;
+    const result = await this.aves.searchCustomers(request);
+    return result.customers; // Fully typed Customer[]
   }
+}
+```
 
-  async createBooking(bookingData: {
-    customerId: string;
-    passengers: any[];
-    services: any[];
-  }): Promise<BookingResponse> {
-    const bookingRequest: CreateBookingRequest = {
-      type: 'individual',
-      priority: 'normal',
-      customerId: bookingData.customerId,
-      passengers: bookingData.passengers,
-      services: bookingData.services,
-    };
+## Type-Safe Search (Discriminated Union)
 
-    return await this.avesService.createBooking(bookingRequest);
-  }
-}
+The search interface uses **discriminated unions** for perfect type safety:
+
+```typescript
+// Search by customer code - TypeScript knows only 'code' is available
+const searchByCode: SearchCustomerRequest = {
+  type: 'code',
+  code: '123456',
+  // Only 'code' property available - type-safe!
+};
+
+// Search by name - different fields available
+const searchByName: SearchCustomerRequest = {
+  type: 'name',
+  name: 'Smith',
+  city: 'New York', // Optional for 'name' type
+};
+
+// Search by VAT code
+const searchByVat: SearchCustomerRequest = {
+  type: 'vat_code',
+  vatCode: 'IT12345678',
+  phoneNumber: '+39123456', // Optional for 'vat_code' type
+};
+
+// Search by last modification date
+const searchByDate: SearchCustomerRequest = {
+  type: 'last_mod_date',
+  from: '2025-01-01',
+  to: '2025-12-31',
+  // 'from' and 'to' are required for this type
+};
 ```
 
-## Clean API Interfaces
+### Available Search Types
 
-The SDK provides developer-friendly interfaces that abstract away XML complexity:
+| Type                | Required Fields   | Optional Fields                    |
+| ------------------- | ----------------- | ---------------------------------- |
+| `code`              | `code`            | `pagination`                       |
+| `name`              | `name`            | `city`, `pagination`               |
+| `vat_code`          | `vatCode`         | `phoneNumber`, `pagination`        |
+| `zone`              | `zipCode`         | `city`, `countyCode`, `pagination` |
+| `category`          | `categoryCode`    | `pagination`                       |
+| `email`             | `email`           | `pagination`                       |
+| `last_mod_date`     | `from`, `to`      | `pagination`                       |
+| `search_field`      | `searchField`     | `pagination`                       |
+| `external_ref_code` | `externalRefCode` | `pagination`                       |
+
+## API Methods
 
 ### Customer Management
 
 ```typescript
-import {
-  Customer,
-  CustomerAddress,
-  CustomerContact,
-  AddressType,
-  CustomerType,
-} from 'aves-sdk';
-
-// Clean, intuitive interfaces
-const customer: Customer = {
-  id: '12345',
+// Search customers
+const result = await aves.searchCustomers({
+  type: 'name',
+  name: 'Rossi',
+  pagination: { pages: 25, page: 1 },
+});
+
+// Create customer
+const customer = await aves.createCustomer({
+  id: '123456',
   type: 'customer',
-  status: 'active',
+  status: 'enabled',
   personalInfo: {
-    title: 'mr',
-    firstName: 'John',
-    lastName: 'Doe',
+    firstName: 'Mario',
+    lastName: 'Rossi',
     dateOfBirth: '1990-01-01',
     gender: 'male',
   },
-  address: {
-    type: 'home',
-    street: '123 Main St',
-    city: 'New York',
-    postalCode: '10001',
-    country: 'US',
-  },
   contact: {
-    phone: {
-      type: 'mobile',
-      number: '+1234567890',
-    },
-    email: {
-      type: 'work',
-      address: 'john.doe@example.com',
-    },
+    email: { address: 'mario.rossi@example.com' },
+    phone: { number: '+39123456789' },
   },
-};
+});
+
+// Update customer
+await aves.updateCustomer(customer);
+
+// Upsert customer (insert or update secondary fields)
+await aves.upsertCustomer(customer);
 ```
 
 ### Booking Management
 
 ```typescript
-import {
-  CreateBookingRequest,
-  BookingPassenger,
-  BookingService,
-  PassengerType,
-  ServiceType,
-} from 'aves-sdk';
-
-const booking: CreateBookingRequest = {
-  type: 'individual',
-  priority: 'normal',
-  customerId: '12345',
+// Create booking
+const booking = await aves.createBooking({
+  customerId: '123456',
+  description: 'Summer vacation package',
+  startDate: '2025-07-01',
+  endDate: '2025-07-14',
+  currency: 'EUR',
   passengers: [
     {
-      id: 'PAX001',
+      id: '001',
       type: 'adult',
-      title: 'mr',
-      firstName: 'John',
-      lastName: 'Doe',
+      firstName: 'Mario',
+      lastName: 'Rossi',
       dateOfBirth: '1990-01-01',
       gender: 'male',
     },
   ],
   services: [
     {
-      id: 'SRV001',
-      type: 'flight',
-      status: 'confirmed',
-      description: 'Flight from NYC to LAX',
-      startDate: '2024-06-01',
-      endDate: '2024-06-01',
+      id: 'HTL001',
+      type: 'hotel',
+      status: 'pending',
+      name: 'Hotel Paradise',
+      startDate: '2025-07-01',
+      endDate: '2025-07-14',
     },
   ],
-};
-```
-
-### Complete Type Safety
-
-The SDK provides **zero `any` types** and complete type safety throughout:
-
-```typescript
-import {
-  CreateBookingRequest,
-  Customer,
-  CustomerAddress,
-  CustomerContact,
-} from 'aves-sdk';
-
-// Fully type-safe customer details in booking
-const booking: CreateBookingRequest = {
-  type: 'individual',
-  priority: 'normal',
-  customerId: '12345',
-  // customerDetails is now properly typed as Customer interface
-  customerDetails: {
-    id: 'CUST001',
-    type: 'customer',
-    status: 'active',
-    personalInfo: {
-      title: 'mr',
-      firstName: 'John',
-      lastName: 'Doe',
-      dateOfBirth: '1990-01-01',
-      gender: 'male',
-    },
-    contact: {
-      phone: {
-        type: 'mobile',
-        number: '+1234567890',
-      },
-      email: {
-        type: 'work',
-        address: 'john.doe@example.com',
-      },
-    },
-    address: {
-      type: 'home',
-      street: '123 Main St',
-      city: 'New York',
-      postalCode: '10001',
-      country: 'US',
-    },
+  statisticCodes: {
+    code2: 'USA',
+    code3: 'GEN',
   },
-  passengers: [...],
-  services: [...],
-};
-
-// Automatic conversion to XML format with full type safety
-const xmlBooking = mapCreateBookingToXml(booking);
-```
-
-## API Reference
-
-### Core Services
-
-#### AvesService
-
-The main service for interacting with the AVES API with clean interfaces.
-
-**Customer Management:**
-
-- `searchCustomer(request: SearchCustomerRequest)` - Search for customers
-- `createCustomer(customer: Customer)` - Create new customer
-- `updateCustomer(customer: Customer)` - Update existing customer
-
-**Booking Management:**
-
-- `createBooking(request: CreateBookingRequest)` - Create new booking
-- `updateBooking(bookingId: string, updates: Partial<CreateBookingRequest>)` - Update booking
-- `cancelBooking(request: CancelBookingRequest)` - Cancel booking
-- `getBooking(bookingId: string)` - Get booking details
-
-**Payment Management:**
-
-- `addPayment(request: AddPaymentRequest)` - Add payment to booking
-- `getPayments(bookingId: string)` - Get payment history
-
-**Document Management:**
-
-- `printDocument(request: PrintDocumentRequest)` - Generate documents
-
-#### AvesValidator
-
-Advanced validation class for comprehensive data validation scenarios.
-
-**Core Methods:**
-
-- `validate(data, schema?)` - Synchronous validation with error throwing
-- `asyncValidate(data, schema?)` - Asynchronous validation with error throwing
-- `safeValidateAndParse(data, schema?)` - Safe validation without throwing errors
-- `safeAsyncValidateAndParse(data, schema?)` - Safe async validation
-
-**Utility Methods:**
+  printDocument: false,
+  sendDocumentViaEmail: false,
+});
 
-- `getErrorMessage(error, separator?)` - Format ZodError messages
-- `getSchema()` - Get current default schema
+// Update booking header
+await aves.updateBookingHeader('123456', 'BK/2025/001', '2025-07-01', {
+  notes: 'Updated booking notes',
+  passengers: [
+    /* updated passengers */
+  ],
+});
 
-**Static Methods:**
+// Set booking status
+await aves.setBookingStatus('123456', 'BK/2025/001', 'confirmed');
 
-- `AvesValidator.withSchema(schema)` - Create validator with specific schema
+// Cancel booking
+await aves.cancelBooking({
+  bookingId: 'BK/2025/001',
+  customerId: '123456',
+});
+```
 
-**Utility Functions:**
+### Document Management
 
-- `createValidator(schema)` - Create validator instance
-- Date utilities with native JavaScript Date for enhanced date manipulation
+```typescript
+// Print booking documents
+const result = await aves.printDocument({
+  bookingId: 'BK/2025/001',
+  customerId: '123456',
+  documentType: 'voucher',
+  format: 'pdf',
+  language: '01',
+});
 
-### Configuration
+// Access generated documents
+result.data.documents.forEach((doc) => {
+  console.log(doc.fileName);
+  console.log(doc.content); // Base64 content
+  console.log(doc.contentSize);
+});
+```
 
-#### AvesSdkConfig
+### Payment Management
 
 ```typescript
-interface AvesSdkConfig {
-  baseUrl: string; // AVES API base URL (validated as URL)
-  hostId: string; // 6-digit host ID (validated)
-  xtoken: string; // Authentication token (required)
-  languageCode?: string; // Language code: '01' (Italian) or '02' (English)
-  timeout?: number; // Request timeout in ms (default: 30000)
-}
+// Add payment
+await aves.addPayment({
+  bookingId: 'BK/2025/001',
+  payments: [
+    {
+      id: 'PAY001',
+      type: 'cash',
+      status: 'confirmed',
+      amount: {
+        currency: 'EUR',
+        amount: 500.0,
+      },
+    },
+  ],
+  enableMultiple: true,
+  operationType: 'absolute',
+});
 ```
 
-### Type Definitions
+## Type Definitions
 
-#### Union Types
-
-The SDK provides strongly-typed union types for better type safety:
+### Customer Types
 
 ```typescript
-type AddressType = 'home' | 'work' | 'billing' | 'delivery';
-type PassengerType = 'adult' | 'child' | 'infant';
-type ServiceType = 'flight' | 'hotel' | 'transfer' | 'activity';
-type PaymentType = 'cash' | 'credit_card' | 'bank_transfer';
-type CustomerType = 'customer' | 'agent' | 'supplier';
-type BookingType = 'individual' | 'group' | 'corporate';
+type CustomerType = 'customer' | 'supplier' | 'voucher' | 'supplier_voucher';
+type CustomerStatusType = 'enabled' | 'warning' | 'blacklisted' | 'disabled';
+type PassengerType = 'adult' | 'child' | 'infant' | 'senior';
+type GenderType = 'male' | 'female';
 ```
 
-#### Date Utilities
-
-Enhanced date manipulation with native JavaScript Date:
+### Booking Types
 
 ```typescript
-import {
-  createDateString,
-  createDateTimeString,
-  createTimeString,
-  formatDateString,
-  isValidDateString,
-  calculateAge,
-  isValidBookingDate,
-} from 'aves-sdk';
-
-// Create validated date strings
-const dateString = createDateString('2024-01-01');
-const dateTimeString = createDateTimeString('2024-01-01T10:30:00');
-const timeString = createTimeString('10:30:00');
-
-// Format dates for display
-const formattedDate = formatDateString('2024-01-01', 'MMM dd, yyyy'); // "Jan 01, 2024"
-
-// Validate date strings
-const isValid = isValidDateString('2024-01-01'); // true
-
-// AVES-specific utilities
-const age = calculateAge('1990-01-01'); // Calculate customer age
-const isBookingValid = isValidBookingDate('2024-06-01'); // Check if booking date is valid
+type BookingStatusType =
+  | 'quotation'
+  | 'work_in_progress'
+  | 'confirmed'
+  | 'optioned'
+  | 'nullified'
+  | 'canceled';
 ```
 
-### Validation
-
-Built-in Zod validation with descriptive error messages:
+### Document Types
 
 ```typescript
-import { configValidationSchema } from 'aves-sdk';
-
-// Configuration validation
-const result = configValidationSchema.safeParse(config);
-if (!result.success) {
-  console.error('Validation errors:', result.error.issues);
-}
-
-// Request validation
-import {
-  SearchCustomerRequestValidation,
-  CreateBookingRequestValidation,
-} from 'aves-sdk';
-
-const searchValidation =
-  SearchCustomerRequestValidation.safeParse(searchRequest);
-const bookingValidation =
-  CreateBookingRequestValidation.safeParse(bookingRequest);
+type DocumentType =
+  | 'visa_request'
+  | 'travel_information'
+  | 'voucher'
+  | 'booking_contract'
+  | 'booking_confirmation'
+  | 'supplier_service_list'
+  | 'invoice'
+  | 'proforma_invoice'
+  | 'adeguamento'
+  | 'reservation_form'
+  | 'open_xml'
+  | 'sales_invoice'
+  | 'ticketing_tmaster'
+  | 'summary_form';
 ```
 
-#### AvesValidator Class
+## Response Interfaces
 
-The SDK provides a comprehensive `AvesValidator` class for advanced validation scenarios:
+### Search Response with Pagination
 
 ```typescript
-import {
-  AvesValidator,
-  configValidationSchema,
-  createValidator,
-} from 'aves-sdk';
-
-// Constructor approach - validator with default schema
-const configValidator = new AvesValidator(configValidationSchema);
-
-// Synchronous validation with error throwing
-try {
-  const validConfig = configValidator.validate(configData);
-  console.log('Valid config:', validConfig);
-} catch (error) {
-  if (error instanceof ZodError) {
-    console.error('Validation errors:', configValidator.getErrorMessage(error));
-  }
-}
-
-// Safe validation without throwing errors
-const result = configValidator.safeValidateAndParse(configData);
-if (result.success) {
-  console.log('Valid config:', result.data);
-} else {
-  console.error('Validation errors:', result.error.issues);
+interface CustomerSearchResult {
+  customers: Customer[];
+  pagination: {
+    page: number; // Current page
+    pages: number; // Minimum known pages
+    totalItems: number; // Items in this response
+    hasMore: boolean; // More results available
+  };
 }
-
-// Asynchronous validation
-const asyncResult = await configValidator.asyncValidate(configData);
-
-// Method approach - validator without default schema
-const validator = new AvesValidator();
-
-// Validate with different schemas
-const configResult = validator.validate(configData, configValidationSchema);
-const searchResult = validator.safeValidateAndParse(
-  searchData,
-  SearchCustomerRequestValidation
-);
-
-// Factory function approach
-const validator = createValidator(configValidationSchema);
-const result = validator.validate(configData);
 ```
 
-**AvesValidator Methods:**
-
-- `validate(data, schema?)` - Synchronous validation with error throwing
-- `asyncValidate(data, schema?)` - Asynchronous validation with error throwing
-- `safeValidateAndParse(data, schema?)` - Safe validation without throwing errors
-- `safeAsyncValidateAndParse(data, schema?)` - Safe async validation
-- `getErrorMessage(error, separator?)` - Format ZodError messages
-- `getSchema()` - Get current default schema
-- `setSchema(schema)` - Set new default schema
-
-### Error Handling
-
-Structured error handling with AVES-specific error codes:
+### Document Print Result
 
 ```typescript
-import { AvesErrorHandler, AvesErrorCodes } from 'aves-sdk';
+interface DocumentPrintResult {
+  emailRecipient?: string;
+  documents: PrintedDocument[];
+  additionalDocuments?: {
+    emailRecipient: string;
+    documents: PrintedDocument[];
+  }[];
+}
 
-@Injectable()
-export class BookingService {
-  constructor(
-    private readonly avesService: AvesService,
-    private readonly errorHandler: AvesErrorHandler
-  ) {}
-
-  async createBooking(data: CreateBookingRequest) {
-    try {
-      const response = await this.avesService.createBooking(data);
-      return response;
-    } catch (error) {
-      const avesError = this.errorHandler.handleHttpError(error);
-
-      switch (avesError.code) {
-        case AvesErrorCodes.BOOKING_NOT_FOUND:
-          throw new NotFoundException('Booking not found');
-        case AvesErrorCodes.INVALID_REQUEST_FORMAT:
-          throw new BadRequestException('Invalid booking data');
-        case AvesErrorCodes.PAYMENT_FAILED:
-          throw new PaymentRequiredException('Payment processing failed');
-        default:
-          throw new InternalServerErrorException(avesError.message);
-      }
-    }
-  }
+interface PrintedDocument {
+  fileName: string;
+  content?: string; // Base64 content
+  contentSize: number;
 }
 ```
 
-## Advanced Usage
+## Validation
 
-### Custom Configuration Factory
+All requests are validated using Zod schemas:
 
 ```typescript
-@Injectable()
-export class CustomAvesConfigService implements AvesOptionsFactory {
-  constructor(private configService: ConfigService) {}
-
-  async createAvesOptions(): Promise<AvesSdkConfig> {
-    // Custom logic to build configuration
-    return {
-      baseUrl: this.configService.get('AVES_BASE_URL')!,
-      hostId: this.configService.get('AVES_HOST_ID')!,
-      xtoken: await this.getTokenFromVault(),
-      languageCode: '01',
-      timeout: 60000,
-    };
-  }
+import { searchCustomerRequestSchema } from 'aves-sdk';
 
-  private async getTokenFromVault(): Promise<string> {
-    // Custom token retrieval logic
-    return 'your-secure-token';
-  }
+const result = searchCustomerRequestSchema.safeParse(request);
+if (!result.success) {
+  console.error(result.error.issues);
 }
-
-// Use in module
-AvesModule.forRootAsync({
-  useClass: CustomAvesConfigService,
-});
 ```
 
-### Custom Error Interceptors
+## Error Handling
 
 ```typescript
-@Injectable()
-export class AvesErrorInterceptor implements NestInterceptor {
-  constructor(private errorHandler: AvesErrorHandler) {}
-
-  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
-    return next.handle().pipe(
-      catchError((error) => {
-        const avesError = this.errorHandler.handleHttpError(error);
-
-        // Custom error mapping
-        const httpStatus = this.mapAvesErrorToHttpStatus(avesError.code);
-
-        throw new HttpException(
-          {
-            message: avesError.message,
-            code: avesError.code,
-            timestamp: avesError.timestamp,
-          },
-          httpStatus
-        );
-      })
-    );
-  }
-
-  private mapAvesErrorToHttpStatus(code: string): number {
-    const statusMap: Record<string, number> = {
-      [AvesErrorCodes.BOOKING_NOT_FOUND]: 404,
-      [AvesErrorCodes.INVALID_REQUEST_FORMAT]: 400,
-      [AvesErrorCodes.PAYMENT_FAILED]: 402,
-    };
+import { AvesErrorHandler, AvesErrorCodes } from 'aves-sdk';
 
-    return statusMap[code] || 500;
-  }
+try {
+  const booking = await aves.createBooking(request);
+} catch (error) {
+  const avesError = errorHandler.handleHttpError(error);
+  console.error(avesError.code, avesError.message);
 }
 ```
 
-### Type-Safe Mappers
-
-```typescript
-import {
-  mapCustomerToXml,
-  mapCustomerFromXml,
-  mapCreateBookingToXml,
-  mapBookingFromXml,
-} from 'aves-sdk';
-
-// Convert clean API data to XML format
-const xmlCustomer = mapCustomerToXml(cleanCustomer);
-const xmlBooking = mapCreateBookingToXml(cleanBooking);
-
-// Convert XML response to clean API format
-const cleanCustomer = mapCustomerFromXml(xmlResponse);
-const cleanBooking = mapBookingFromXml(xmlResponse);
-```
-
-## Development
+## Bundle Size
 
-### Building
+Optimized for production:
 
-```bash
-yarn build
-```
+- **ESM**: 51.75 KB (gzipped)
+- **CJS**: 55.13 KB (gzipped)
+- **DTS**: 137.03 KB
 
-### Testing
+## Architecture
 
-```bash
-yarn test
 ```
-
-### Linting
-
-```bash
-yarn lint
+aves-sdk/
+├── validation/
+│   └── api-schemas.ts         # Zod schemas + inferred types (single source of truth)
+├── types/
+│   ├── interfaces.ts           # XML layer (Aves API)
+│   └── common.ts              # Shared types
+├── mappers/
+│   ├── request-mappers.ts     # API → XML
+│   ├── response-mappers.ts    # XML → API
+│   └── type-mappers.ts        # Enum conversions
+├── nest/
+│   ├── aves.module.ts         # NestJS module
+│   └── aves.service.ts        # Main service
+└── config/
+    ├── endpoints.ts           # API endpoints
+    └── root-elements.ts       # XML root elements
 ```
 
-## Migration Guide
-
-### From v0.x to v1.x
-
-The SDK has been completely rewritten with clean APIs and Zod validation:
-
-**Old (v0.x):**
-
-```typescript
-// Complex XML interfaces
-const searchRequest: SearchMasterRecordRQ = {
-  SearchCriteria: {
-    MasterRecordType: 'CUSTOMER',
-    SearchFields: {
-      Field: [
-        {
-          '@Name': 'LastName',
-          '@Value': 'Smith',
-          '@Operator': 'CONTAINS',
-        },
-      ],
-    },
-  },
-};
-```
-
-**New (v1.x):**
-
-```typescript
-// Clean, developer-friendly interfaces
-const searchRequest: SearchCustomerRequest = {
-  type: 'customer',
-  fields: [
-    {
-      name: 'LastName',
-      value: 'Smith',
-      operator: 'contains',
-    },
-  ],
-};
-```
-
-## Contributing
-
-1. Fork the repository
-2. Create a feature branch
-3. Make your changes
-4. Add tests
-5. Submit a pull request
-
 ## License
 
-MIT License - see LICENSE file for details.
-
-## Support
-
-For issues and questions:
-
-- Create an issue on GitHub
-- Check the examples in `/examples` directory
-- Review the AVES technical documentation
-
-## Changelog
-
-### v1.0.0
-
-- **Clean API Interfaces** - Developer-friendly interfaces abstracting XML complexity
-- **Bidirectional Mappers** - Seamless conversion between clean and XML formats
-- **AvesValidator Class** - Comprehensive validation class with sync/async methods and utility functions
-- **Complete Type Safety** - Full TypeScript coverage with comprehensive interfaces for both clean API objects and XML structures, ensuring type safety throughout the entire request/response lifecycle
-- **Customer Mapper** - Full `Customer` to `MasterRecord` conversion with `mapCustomerToXml`
-- **Global Module** - NestJS global module for application-wide availability
-- **Enhanced Error Handling** - Structured error handling with AVES-specific codes
-- **Comprehensive Documentation** - Complete API reference and examples
-- **Production Ready** - Enterprise-grade implementation following NestJS best practices
+MIT
 
-### Breaking Changes from v0.x
+## Credits
 
-- Replaced `class-validator` with Zod validation
-- Introduced clean API interfaces alongside XML interfaces
-- Enhanced date utilities with native JavaScript Date
-- Updated module configuration with enhanced validation
-- Improved error handling structure
+Built for the Aves XML 1.8.0 Booking CPX API specification.