adserver-dashboard 1.0.0

package/PCM/tests/e2e-comprehensive.test.js

@@ -0,0 +1,3446 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert';
+
+const BASE_URL = 'http://localhost:5000/api/v1/rest';
+
+async function request(method, path, body = null) {
+  const options = {
+    method,
+    headers: { 'Content-Type': 'application/json' }
+  };
+  if (body) options.body = JSON.stringify(body);
+  const res = await fetch(`${BASE_URL}${path}`, options);
+  const data = await res.json();
+  return { status: res.status, data };
+}
+
+describe('E2E Comprehensive Test Suite', () => {
+  const testData = {
+    deals: {},
+    lineItems: {},
+    creatives: {}
+  };
+
+  describe('1. PROGRAMMATIC Mode - GUARANTEED Deal', () => {
+    const dealPayload = {
+      name: 'E2E Guaranteed Campaign',
+      externalId: `e2e-guaranteed-${Date.now()}`,
+      source: 'e2e-test',
+      mode: 'PROGRAMMATIC',
+      dealType: 'GUARANTEED',
+      currency: 'USD',
+      seller: { id: 'seller-001', name: 'Test Seller' },
+      programmatic: {
+        buyers: [{ id: 'buyer-001', name: 'Test Buyer' }],
+        transactionType: 'SPOT',
+        costType: 'CPM'
+      }
+    };
+
+    it('should create a GUARANTEED deal', async () => {
+      const { status, data } = await request('POST', '/deals', dealPayload);
+      assert.strictEqual(status, 201);
+      assert.ok(data.result.dealId.startsWith('GD'));
+      testData.deals.guaranteed = data.result;
+    });
+
+    it('should get deal by dealId with full details', async () => {
+      const { status, data } = await request('GET', `/deals/${testData.deals.guaranteed.dealId}`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.name, dealPayload.name);
+      assert.strictEqual(data.result.mode, 'PROGRAMMATIC');
+      assert.strictEqual(data.result.dealType, 'GUARANTEED');
+      assert.strictEqual(data.result.programmatic.auctionType, 3);
+      testData.deals.guaranteed = data.result;
+    });
+
+    it('should get deal by UUID', async () => {
+      const { status, data } = await request('GET', `/deals/${testData.deals.guaranteed.id}`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.id, testData.deals.guaranteed.id);
+    });
+
+    it('should create a DISPLAY line item', async () => {
+      const lineItemPayload = {
+        externalId: `e2e-li-display-${Date.now()}`,
+        name: 'Display Line Item',
+        creativeType: 'DISPLAY',
+        duration: 15,
+        timezoneId: 'America/New_York',
+        startDate: '2025-01-01',
+        endDate: '2025-03-31',
+        resolutions: ['1920x1080', '1280x720'],
+        programmatic: {
+          costType: 'CPM',
+          bidFloor: 5.00,
+          deliveryGoal: 100000,
+          netCost: 500,
+          thresholdCountPerDay: 100
+        }
+      };
+      const { status, data } = await request('POST', `/deals/${testData.deals.guaranteed.dealId}/line-items`, lineItemPayload);
+      assert.strictEqual(status, 201);
+      testData.lineItems.display = data.result;
+    });
+
+    it('should get line item by id with full details', async () => {
+      const { status, data } = await request('GET', `/deals/${testData.deals.guaranteed.dealId}/line-items/${testData.lineItems.display.id}`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.creativeType, 'DISPLAY');
+      testData.lineItems.display = data.result;
+    });
+
+    it('should update deal status to APPROVED for creative assignment', async () => {
+      const { status, data } = await request('PUT', `/deals/${testData.deals.guaranteed.dealId}`, { status: 'APPROVED' });
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.status, 'APPROVED');
+      testData.deals.guaranteed = data.result;
+    });
+
+    it('should get line items by dealId', async () => {
+      const { status, data } = await request('GET', `/deals/${testData.deals.guaranteed.dealId}/line-items`);
+      assert.strictEqual(status, 200);
+      assert.ok(data.result.data.length >= 1);
+    });
+
+    it('should get line item by externalId', async () => {
+      const { status, data } = await request('GET', `/deals/${testData.deals.guaranteed.dealId}/line-items/${testData.lineItems.display.externalId}`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.externalId, testData.lineItems.display.externalId);
+    });
+
+    it('should update line item', async () => {
+      const { status, data } = await request('PUT', `/deals/${testData.deals.guaranteed.dealId}/line-items/${testData.lineItems.display.externalId}`, {
+        name: 'Updated Display Line Item',
+        programmatic: { bidFloor: 6.50 }
+      });
+      assert.strictEqual(status, 200);
+      assert.ok(data.result.version >= 1);
+      const { data: getResult } = await request('GET', `/deals/${testData.deals.guaranteed.dealId}/line-items/${testData.lineItems.display.externalId}`);
+      assert.strictEqual(getResult.result.name, 'Updated Display Line Item');
+    });
+
+    it('should assign DISPLAY creative with matching resolution', async () => {
+      const creativePayload = {
+        creativeId: `e2e-creative-display-${Date.now()}`,
+        creativeUri: 'https://cdn.example.com/ad.jpg',
+        creativeType: 'DISPLAY',
+        resolution: '1920x1080',
+        thumbnail: 'https://cdn.example.com/thumb.jpg'
+      };
+      const { status, data } = await request('POST', `/deals/${testData.deals.guaranteed.dealId}/line-items/${testData.lineItems.display.externalId}/creatives`, creativePayload);
+      assert.strictEqual(status, 201);
+      assert.strictEqual(data.result.status, 'PENDING');
+      testData.creatives.display = data.result;
+    });
+
+    it('should reject creative with mismatched resolution', async () => {
+      const { status, data } = await request('POST', `/deals/${testData.deals.guaranteed.dealId}/line-items/${testData.lineItems.display.externalId}/creatives`, {
+        creativeId: `e2e-creative-bad-res-${Date.now()}`,
+        creativeUri: 'https://cdn.example.com/ad2.jpg',
+        creativeType: 'DISPLAY',
+        resolution: '800x600'
+      });
+      assert.strictEqual(status, 400);
+      assert.ok(data.message.includes('not in line item'));
+    });
+
+    it('should reject creative with mismatched type', async () => {
+      const { status, data } = await request('POST', `/deals/${testData.deals.guaranteed.dealId}/line-items/${testData.lineItems.display.externalId}/creatives`, {
+        creativeId: `e2e-creative-bad-type-${Date.now()}`,
+        creativeUri: 'https://cdn.example.com/ad.mp4',
+        creativeType: 'VIDEO',
+        resolution: '1920x1080',
+        duration: 30
+      });
+      assert.strictEqual(status, 400);
+      assert.ok(data.message.includes('type mismatch'));
+    });
+
+    it('should approve pending creative', async () => {
+      const { status, data } = await request('POST', `/deals/${testData.deals.guaranteed.dealId}/line-items/${testData.lineItems.display.externalId}/creatives/${testData.creatives.display.creativeId}`, {
+        decision: 'APPROVED',
+        reviewerId: 'reviewer-001',
+        reviewerName: 'John Reviewer'
+      });
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.status, 'APPROVED');
+    });
+
+    it('should not allow rejecting approved creative', async () => {
+      const { status, data } = await request('POST', `/deals/${testData.deals.guaranteed.dealId}/line-items/${testData.lineItems.display.externalId}/creatives/${testData.creatives.display.creativeId}`, {
+        decision: 'REJECTED',
+        reason: 'Changed my mind'
+      });
+      assert.strictEqual(status, 400);
+      assert.ok(data.message.includes('Cannot reject an approved'));
+    });
+
+    it('should get creatives by dealId', async () => {
+      const { status, data } = await request('GET', `/deals/${testData.deals.guaranteed.dealId}/creatives`);
+      assert.strictEqual(status, 200);
+      assert.ok(data.result.data.length >= 1);
+    });
+
+    it('should get creatives by lineItemId', async () => {
+      const { status, data } = await request('GET', `/deals/${testData.deals.guaranteed.dealId}/line-items/${testData.lineItems.display.externalId}/creatives`);
+      assert.strictEqual(status, 200);
+      assert.ok(data.result.data.length >= 1);
+    });
+
+    it('should get creative by creativeId', async () => {
+      const { status, data } = await request('GET', `/deals/${testData.deals.guaranteed.dealId}/line-items/${testData.lineItems.display.externalId}/creatives/${testData.creatives.display.creativeId}`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.creativeId, testData.creatives.display.creativeId);
+    });
+
+    it('should get creative by UUID', async () => {
+      const { status, data } = await request('GET', `/deals/${testData.deals.guaranteed.dealId}/line-items/${testData.lineItems.display.externalId}/creatives/${testData.creatives.display.id}`);
+      assert.strictEqual(status, 200);
+    });
+  });
+
+  describe('2. PROGRAMMATIC Mode - PREFERRED_DEAL', () => {
+    it('should create a PREFERRED_DEAL with CPS cost type', async () => {
+      const { status, data } = await request('POST', '/deals', {
+        name: 'E2E Preferred Deal Campaign',
+        externalId: `e2e-preferred-${Date.now()}`,
+        source: 'e2e-test',
+        mode: 'PROGRAMMATIC',
+        dealType: 'PREFERRED_DEAL',
+        currency: 'USD',
+        seller: { id: 'seller-001', name: 'Test Seller' },
+        programmatic: {
+          buyers: [{ id: 'buyer-002', name: 'Preferred Buyer' }],
+          transactionType: 'SPOT',
+          costType: 'CPS'
+        }
+      });
+      assert.strictEqual(status, 201);
+      assert.ok(data.result.dealId.startsWith('PD'));
+      testData.deals.preferred = data.result;
+    });
+
+    it('should verify PREFERRED_DEAL has auctionType 3', async () => {
+      const { status, data } = await request('GET', `/deals/${testData.deals.preferred.dealId}`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.programmatic.auctionType, 3);
+    });
+  });
+
+  describe('3. PROGRAMMATIC Mode - PRIVATE_AUCTION', () => {
+    it('should create a PRIVATE_AUCTION with first price auction', async () => {
+      const { status, data } = await request('POST', '/deals', {
+        name: 'E2E Private Auction Campaign',
+        externalId: `e2e-private-auction-${Date.now()}`,
+        source: 'e2e-test',
+        mode: 'PROGRAMMATIC',
+        dealType: 'PRIVATE_AUCTION',
+        currency: 'EUR',
+        seller: { id: 'seller-001', name: 'Test Seller' },
+        programmatic: {
+          buyers: [{ id: 'buyer-003', name: 'Auction Buyer' }],
+          auctionType: 1,
+          transactionType: 'AUDIENCE',
+          costType: 'CPM'
+        }
+      });
+      assert.strictEqual(status, 201);
+      assert.ok(data.result.dealId.startsWith('PA'));
+      testData.deals.privateAuction = data.result;
+    });
+
+    it('should verify PRIVATE_AUCTION has auctionType 1', async () => {
+      const { status, data } = await request('GET', `/deals/${testData.deals.privateAuction.dealId}`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.programmatic.auctionType, 1);
+      testData.deals.privateAuction = data.result;
+    });
+
+    it('should create VIDEO line item', async () => {
+      const { status, data } = await request('POST', `/deals/${testData.deals.privateAuction.dealId}/line-items`, {
+        externalId: `e2e-li-video-${Date.now()}`,
+        name: 'Video Line Item',
+        creativeType: 'VIDEO',
+        timezoneId: 'Europe/London',
+        startDate: '2025-02-01',
+        endDate: '2025-04-30',
+        resolutions: ['1920x1080'],
+        programmatic: {
+          duration: 30,
+          costType: 'CPM',
+          bidFloor: 10.00
+        }
+      });
+      assert.strictEqual(status, 201);
+      testData.lineItems.video = data.result;
+    });
+
+    it('should update PRIVATE_AUCTION deal status to APPROVED', async () => {
+      const { status, data } = await request('PUT', `/deals/${testData.deals.privateAuction.dealId}`, { status: 'APPROVED' });
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.status, 'APPROVED');
+    });
+
+    it('should assign VIDEO creative', async () => {
+      const { status, data } = await request('POST', `/deals/${testData.deals.privateAuction.dealId}/line-items/${testData.lineItems.video.externalId}/creatives`, {
+        creativeId: `e2e-creative-video-${Date.now()}`,
+        creativeUri: 'https://cdn.example.com/video.mp4',
+        creativeType: 'VIDEO',
+        resolution: '1920x1080',
+        duration: 30,
+        mimeType: 'video/mp4'
+      });
+      assert.strictEqual(status, 201);
+      testData.creatives.video = data.result;
+    });
+
+    it('should reject VIDEO creative', async () => {
+      const { status, data } = await request('POST', `/deals/${testData.deals.privateAuction.dealId}/line-items/${testData.lineItems.video.externalId}/creatives/${testData.creatives.video.creativeId}`, {
+        decision: 'REJECTED',
+        reviewerId: 'reviewer-002',
+        reviewerName: 'Jane Reviewer',
+        reason: 'Video quality is too low'
+      });
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.status, 'REJECTED');
+    });
+
+    it('should not allow approving rejected creative', async () => {
+      const { status, data } = await request('POST', `/deals/${testData.deals.privateAuction.dealId}/line-items/${testData.lineItems.video.externalId}/creatives/${testData.creatives.video.creativeId}`, {
+        decision: 'APPROVED'
+      });
+      assert.strictEqual(status, 400);
+      assert.ok(data.message.includes('Cannot approve a rejected'));
+    });
+  });
+
+  describe('4. PROGRAMMATIC Mode - EVERGREEN_PMP', () => {
+    it('should create an EVERGREEN_PMP with second price auction', async () => {
+      const { status, data } = await request('POST', '/deals', {
+        name: 'E2E Evergreen PMP Campaign',
+        externalId: `e2e-evergreen-${Date.now()}`,
+        source: 'e2e-test',
+        mode: 'PROGRAMMATIC',
+        dealType: 'EVERGREEN_PMP',
+        currency: 'GBP',
+        seller: { id: 'seller-002', name: 'UK Seller' },
+        programmatic: {
+          buyers: [{ id: 'buyer-004', name: 'Evergreen Buyer' }],
+          auctionType: 2,
+          transactionType: 'SPOT',
+          costType: 'CPD'
+        }
+      });
+      assert.strictEqual(status, 201);
+      assert.ok(data.result.dealId.startsWith('EG'));
+      testData.deals.evergreen = data.result;
+    });
+
+    it('should verify EVERGREEN_PMP has auctionType 2', async () => {
+      const { status, data } = await request('GET', `/deals/${testData.deals.evergreen.dealId}`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.programmatic.auctionType, 2);
+      testData.deals.evergreen = data.result;
+    });
+
+    it('should update EVERGREEN_PMP deal status to APPROVED', async () => {
+      const { status, data } = await request('PUT', `/deals/${testData.deals.evergreen.dealId}`, { status: 'APPROVED' });
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.status, 'APPROVED');
+    });
+
+    it('should create AUDIO line item', async () => {
+      const { status, data } = await request('POST', `/deals/${testData.deals.evergreen.dealId}/line-items`, {
+        externalId: `e2e-li-audio-${Date.now()}`,
+        name: 'Audio Line Item',
+        creativeType: 'AUDIO',
+        timezoneId: 'Europe/London',
+        startDate: '2025-01-15',
+        endDate: '2025-06-30',
+        programmatic: {
+          duration: 60,
+          costType: 'CPD',
+          bidFloor: 2.00
+        }
+      });
+      assert.strictEqual(status, 201);
+      testData.lineItems.audio = data.result;
+    });
+
+    it('should assign AUDIO creative (no resolution required)', async () => {
+      const { status, data } = await request('POST', `/deals/${testData.deals.evergreen.dealId}/line-items/${testData.lineItems.audio.externalId}/creatives`, {
+        creativeId: `e2e-creative-audio-${Date.now()}`,
+        creativeUri: 'https://cdn.example.com/audio.mp3',
+        creativeType: 'AUDIO',
+        duration: 60,
+        mimeType: 'audio/mpeg'
+      });
+      assert.strictEqual(status, 201);
+      testData.creatives.audio = data.result;
+    });
+
+    it('should approve AUDIO creative', async () => {
+      const { status, data } = await request('POST', `/deals/${testData.deals.evergreen.dealId}/line-items/${testData.lineItems.audio.externalId}/creatives/${testData.creatives.audio.creativeId}`, {
+        decision: 'APPROVED'
+      });
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.status, 'APPROVED');
+    });
+  });
+
+  describe('5. DIRECT Mode', () => {
+    it('should create a DIRECT deal', async () => {
+      const payload = {
+        name: 'E2E Direct Campaign',
+        externalId: `e2e-direct-${Date.now()}`,
+        source: 'e2e-test',
+        mode: 'DIRECT',
+        currency: 'USD',
+        seller: { id: 'seller-003', name: 'Direct Seller' },
+        direct: {
+          brand: 'Test Brand',
+          clientType: 'AGENCY',
+          approvalEmails: ['approver@test.com'],
+          marketSelection: { country: 'US', currency: 'USD' },
+          budgetSetup: { currency: 'USD', budgetAmount: 10000 },
+          campaignGoal: { type: 'IMPRESSIONS', targetValue: 500000 }
+        }
+      };
+      const { status, data } = await request('POST', '/deals', payload);
+      assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+      assert.ok(data.result.dealId.startsWith('DIR'));
+      testData.deals.direct = data.result;
+    });
+
+    it('should verify DIRECT deal has correct mode and type', async () => {
+      const { status, data } = await request('GET', `/deals/${testData.deals.direct.dealId}`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.mode, 'DIRECT');
+      assert.strictEqual(data.result.dealType, 'DIRECT');
+      testData.deals.direct = data.result;
+    });
+
+    it('should create DIRECT line item with comprehensive targeting (demographics, venueTypes, geofencing)', async () => {
+      const { status, data } = await request('POST', `/deals/${testData.deals.direct.dealId}/line-items`, {
+        externalId: `e2e-li-direct-${Date.now()}`,
+        name: 'Direct Display Line Item with Full Targeting',
+        creativeType: 'DISPLAY',
+        timezoneId: 'America/Los_Angeles',
+        startDate: '2025-03-01',
+        endDate: '2025-05-31',
+        resolutions: ['1920x1080', '3840x2160'],
+        targeting: {
+          demographics: {
+            ageGroups: ['25-34', '35-44'],
+            genders: ['male', 'female'],
+            incomeGroups: ['middle', 'upper-middle'],
+            interests: ['technology', 'automotive'],
+            audienceBehaviour: ['daily_commuter', 'frequent_shopper']
+          },
+          venueTypes: [
+            'transit.train_stations',
+            'transit.train_stations.platform',
+            'retail.shopping_mall'
+          ],
+          geofencing: {
+            geometrics: [
+              {
+                type: 'Polygon',
+                coordinates: [[[-118.25, 34.04], [-118.24, 34.04], [-118.24, 34.05], [-118.25, 34.05], [-118.25, 34.04]]],
+                included: true
+              }
+            ],
+            locations: [
+              {
+                name: 'Downtown LA',
+                lat: 34.0522,
+                lng: -118.2437,
+                radius: 2000,
+                address: 'Los Angeles, CA',
+                metadata: { type: 'circle' },
+                included: true
+              }
+            ]
+          }
+        },
+        deliveryTargeting: {
+          signals: {
+            weather: {
+              conditions: ['sunny', 'partly_cloudy'],
+              temperature: { min: 20, max: 35, unit: 'celsius' }
+            }
+          }
+        },
+        metadata: {
+          inventoryFilteredBy: ['demographics', 'venueTypes', 'geofencing'],
+          deliveryTriggeredBy: ['weather'],
+          venueTaxonomyFormat: 'dot-notation',
+          version: '1.0'
+        },
+        direct: {
+          budgetSetup: { budgetType: 'DAILY', budgetAmount: 500, currency: 'USD' },
+          campaignGoal: { type: 'SHARE_OF_VOICE', targetValue: 25 }
+        }
+      });
+      assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+      testData.lineItems.direct = data.result;
+    });
+
+    it('should return comprehensive targeting in DIRECT line item response', async () => {
+      const { status, data } = await request('GET', `/deals/${testData.deals.direct.dealId}/line-items/${testData.lineItems.direct.externalId}`);
+      assert.strictEqual(status, 200);
+      
+      assert.ok(data.result.targeting, 'Expected targeting in response');
+      assert.ok(data.result.targeting.demographics, 'Expected demographics in targeting');
+      assert.deepStrictEqual(data.result.targeting.demographics.ageGroups, ['25-34', '35-44']);
+      assert.ok(data.result.targeting.venueTypes, 'Expected venueTypes in targeting');
+      assert.ok(data.result.targeting.venueTypes.includes('transit.train_stations'));
+      assert.ok(data.result.targeting.geofencing, 'Expected geofencing in targeting');
+      assert.ok(data.result.targeting.geofencing.locations.length > 0, 'Expected locations in geofencing');
+      
+      assert.ok(data.result.deliveryTargeting, 'Expected deliveryTargeting in response');
+      assert.ok(data.result.deliveryTargeting.signals, 'Expected signals in deliveryTargeting');
+      assert.ok(data.result.deliveryTargeting.signals.weather, 'Expected weather signal');
+      
+      assert.ok(data.result.metadata, 'Expected metadata in response');
+      assert.strictEqual(data.result.metadata.version, '1.0');
+      assert.strictEqual(data.result.metadata.venueTaxonomyFormat, 'dot-notation');
+    });
+
+    it('should update DIRECT line item targeting', async () => {
+      const { status, data } = await request('PUT', `/deals/${testData.deals.direct.dealId}/line-items/${testData.lineItems.direct.externalId}`, {
+        targeting: {
+          demographics: {
+            ageGroups: ['18-24', '25-34', '35-44'],
+            genders: ['male', 'female'],
+            incomeGroups: ['high'],
+            interests: ['luxury', 'travel'],
+            audienceBehaviour: ['premium_consumer']
+          },
+          venueTypes: ['transit.airports', 'transit.airports.lounge'],
+          geofencing: {
+            locations: [
+              {
+                name: 'LAX Airport',
+                lat: 33.9425,
+                lng: -118.4081,
+                radius: 5000,
+                address: 'Los Angeles International Airport',
+                metadata: { type: 'place' },
+                included: true
+              }
+            ]
+          }
+        },
+        deliveryTargeting: {
+          signals: {
+            weather: { conditions: ['any'] }
+          }
+        },
+        metadata: {
+          inventoryFilteredBy: ['demographics', 'venueTypes', 'geofencing'],
+          deliveryTriggeredBy: ['weather'],
+          venueTaxonomyFormat: 'dot-notation',
+          version: '1.1'
+        }
+      });
+      assert.strictEqual(status, 200, `Failed: ${JSON.stringify(data)}`);
+      
+      const getRes = await request('GET', `/deals/${testData.deals.direct.dealId}/line-items/${testData.lineItems.direct.externalId}`);
+      assert.ok(getRes.data.result.targeting.demographics.ageGroups.includes('18-24'), 'Expected updated ageGroups');
+      assert.ok(getRes.data.result.targeting.venueTypes.includes('transit.airports'), 'Expected updated venueTypes');
+      assert.strictEqual(getRes.data.result.metadata.version, '1.1', 'Expected updated metadata version');
+    });
+
+    it('should assign creative to DIRECT line item', async () => {
+      const { status, data } = await request('POST', `/deals/${testData.deals.direct.dealId}/line-items/${testData.lineItems.direct.externalId}/creatives`, {
+        creativeId: `e2e-creative-direct-${Date.now()}`,
+        creativeUri: 'https://cdn.example.com/direct-ad.jpg',
+        creativeType: 'DISPLAY',
+        resolution: '3840x2160'
+      });
+      assert.strictEqual(status, 201);
+      testData.creatives.direct = data.result;
+    });
+
+    it('should create DIRECT line item with planning data', async () => {
+      const planningPayload = {
+        externalId: `e2e-li-planning-${Date.now()}`,
+        name: 'Direct Line Item with Planning',
+        creativeType: 'DISPLAY',
+        timezoneId: 'America/New_York',
+        startDate: '2025-04-01',
+        endDate: '2025-04-30',
+        resolutions: ['1920x1080'],
+        direct: {
+          budgetSetup: { type: 'TOTAL', amount: 15000, currency: 'USD' },
+          campaignGoal: { type: 'IMPRESSIONS', target: 500000 },
+          planning: {
+            capacity: {
+              campaignDays: 30,
+              available: { slots: 238080, playTimeSec: 3571200, maxImpressions: 28000000 }
+            },
+            allocation: { slots: 5270, playTimeSec: 79050, sov: 0.04427, sot: 0.04379 },
+            estimates: { impressions: 1245000, reach: 285000, frequency: 4.37 },
+            pricing: { cpm: 2185.00, estimatedCost: 149299.10 }
+          }
+        }
+      };
+      const { status, data } = await request('POST', `/deals/${testData.deals.direct.dealId}/line-items`, planningPayload);
+      assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+      testData.lineItems.directWithPlanning = data.result;
+    });
+
+    it('should return planning data in DIRECT line item response', async () => {
+      const { status, data } = await request('GET', `/deals/${testData.deals.direct.dealId}/line-items/${testData.lineItems.directWithPlanning.externalId}`);
+      assert.strictEqual(status, 200);
+      assert.ok(data.result.direct, 'Expected direct object in response');
+      assert.ok(data.result.direct.planning, 'Expected planning in direct object');
+      assert.ok(data.result.direct.planning.capacity, 'Expected capacity in planning');
+      assert.strictEqual(data.result.direct.planning.capacity.campaignDays, 30);
+      assert.strictEqual(data.result.direct.planning.allocation.slots, 5270);
+      assert.strictEqual(data.result.direct.planning.estimates.impressions, 1245000);
+    });
+
+    it('should update DIRECT line item planning data', async () => {
+      const { status, data } = await request('PUT', `/deals/${testData.deals.direct.dealId}/line-items/${testData.lineItems.directWithPlanning.externalId}`, {
+        direct: {
+          planning: {
+            allocation: { slots: 6000, playTimeSec: 90000, sov: 0.05, sot: 0.05 },
+            estimates: { impressions: 1500000, reach: 300000, frequency: 5.0 },
+            pricing: { cpm: 2000.00, estimatedCost: 180000.00 }
+          }
+        }
+      });
+      assert.strictEqual(status, 200, `Failed: ${JSON.stringify(data)}`);
+    });
+
+    it('should verify updated planning data persisted', async () => {
+      const { status, data } = await request('GET', `/deals/${testData.deals.direct.dealId}/line-items/${testData.lineItems.directWithPlanning.externalId}`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.direct.planning.allocation.slots, 6000);
+      assert.strictEqual(data.result.direct.planning.estimates.impressions, 1500000);
+      assert.strictEqual(data.result.direct.planning.pricing.estimatedCost, 180000.00);
+    });
+
+    it('should aggregate planning from line items to deal level', async () => {
+      const { status, data } = await request('GET', `/deals/${testData.deals.direct.dealId}`);
+      assert.strictEqual(status, 200);
+      assert.ok(data.result.direct, 'Expected direct object in deal response');
+      assert.ok(data.result.direct.planning, 'Expected aggregated planning in deal');
+      assert.ok(data.result.direct.planning.allocation, 'Expected allocation in aggregated planning');
+      assert.ok(data.result.direct.planning.estimates, 'Expected estimates in aggregated planning');
+    });
+
+    it('should create second DIRECT line item with different planning for aggregation test', async () => {
+      const planningPayload = {
+        externalId: `e2e-li-planning-2-${Date.now()}`,
+        name: 'Second Direct Line Item with Planning',
+        creativeType: 'DISPLAY',
+        timezoneId: 'America/New_York',
+        startDate: '2025-04-01',
+        endDate: '2025-04-30',
+        resolutions: ['1920x1080'],
+        direct: {
+          budgetSetup: { type: 'TOTAL', amount: 10000, currency: 'USD' },
+          campaignGoal: { type: 'IMPRESSIONS', target: 300000 },
+          planning: {
+            capacity: {
+              campaignDays: 30,
+              available: { slots: 100000, playTimeSec: 1500000, maxImpressions: 12000000 }
+            },
+            allocation: { slots: 4000, playTimeSec: 60000, sov: 0.04, sot: 0.04 },
+            estimates: { impressions: 500000, reach: 100000, frequency: 5.0 },
+            pricing: { cpm: 2400.00, estimatedCost: 120000.00 }
+          }
+        }
+      };
+      const { status, data } = await request('POST', `/deals/${testData.deals.direct.dealId}/line-items`, planningPayload);
+      assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+      testData.lineItems.directWithPlanning2 = data.result;
+    });
+
+    it('should correctly aggregate planning from multiple line items', async () => {
+      const { status, data } = await request('GET', `/deals/${testData.deals.direct.dealId}`);
+      assert.strictEqual(status, 200);
+      const planning = data.result.direct.planning;
+      assert.ok(planning, 'Expected aggregated planning');
+      assert.ok(planning.estimates.impressions > 0, 'Aggregated impressions should be positive');
+      assert.ok(planning.allocation.slots > 0, 'Aggregated slots should be positive');
+      assert.ok(planning.pricing.estimatedCost > 0, 'Aggregated estimated cost should be positive');
+      assert.ok(planning.pricing.cpm > 0, 'Aggregated CPM should be calculated');
+      assert.ok(planning.estimates.frequency > 0, 'Aggregated frequency should be calculated');
+    });
+  });
+
+  describe('6. Deal List Filtering', () => {
+    it('should get all deals', async () => {
+      const { status, data } = await request('GET', '/deals');
+      assert.strictEqual(status, 200);
+      assert.ok(Array.isArray(data.result.data));
+    });
+
+    it('should filter deals by mode=PROGRAMMATIC', async () => {
+      const { status, data } = await request('GET', '/deals?mode=PROGRAMMATIC');
+      assert.strictEqual(status, 200);
+      assert.ok(Array.isArray(data.result.data));
+      data.result.data.forEach(deal => assert.strictEqual(deal.mode, 'PROGRAMMATIC'));
+    });
+
+    it('should filter deals by mode=DIRECT', async () => {
+      const { status, data } = await request('GET', '/deals?mode=DIRECT');
+      assert.strictEqual(status, 200);
+      assert.ok(Array.isArray(data.result.data));
+      data.result.data.forEach(deal => assert.strictEqual(deal.mode, 'DIRECT'));
+    });
+
+    it('should filter deals by dealType=GUARANTEED', async () => {
+      const { status, data } = await request('GET', '/deals?dealType=GUARANTEED');
+      assert.strictEqual(status, 200);
+      assert.ok(Array.isArray(data.result.data));
+      data.result.data.forEach(deal => assert.strictEqual(deal.dealType, 'GUARANTEED'));
+    });
+
+    it('should filter deals by source', async () => {
+      const { status, data } = await request('GET', '/deals?source=e2e-test');
+      assert.strictEqual(status, 200);
+      assert.ok(Array.isArray(data.result.data));
+    });
+
+    it('should search deals by name', async () => {
+      const { status, data } = await request('GET', '/deals?search=Evergreen');
+      assert.strictEqual(status, 200);
+      assert.ok(Array.isArray(data.result.data));
+    });
+
+    it('should filter deals by currency', async () => {
+      const { status, data } = await request('GET', '/deals?currency=EUR');
+      assert.strictEqual(status, 200);
+      assert.ok(Array.isArray(data.result.data));
+      data.result.data.forEach(deal => assert.strictEqual(deal.currency, 'EUR'));
+    });
+  });
+
+  describe('7. Validation Rules', () => {
+    it('should reject GUARANTEED deal with CPS cost type', async () => {
+      const { status, data } = await request('POST', '/deals', {
+        name: 'Invalid GUARANTEED',
+        externalId: `invalid-gd-${Date.now()}`,
+        source: 'e2e-test',
+        mode: 'PROGRAMMATIC',
+        dealType: 'GUARANTEED',
+        currency: 'USD',
+        seller: { id: 'seller-001', name: 'Test' },
+        programmatic: {
+          buyers: [{ id: 'b1', name: 'Buyer' }],
+          costType: 'CPS'
+        }
+      });
+      assert.strictEqual(status, 400);
+    });
+
+    it('should reject PRIVATE_AUCTION with auctionType 3', async () => {
+      const { status, data } = await request('POST', '/deals', {
+        name: 'Invalid Auction Type',
+        externalId: `invalid-pa-${Date.now()}`,
+        source: 'e2e-test',
+        mode: 'PROGRAMMATIC',
+        dealType: 'PRIVATE_AUCTION',
+        currency: 'USD',
+        seller: { id: 'seller-001', name: 'Test' },
+        programmatic: {
+          buyers: [{ id: 'b1', name: 'Buyer' }],
+          auctionType: 3,
+          costType: 'CPM'
+        }
+      });
+      assert.strictEqual(status, 400);
+    });
+
+    it('should auto-set dealType to DIRECT for DIRECT mode', async () => {
+      const { status, data } = await request('POST', '/deals', {
+        name: 'Auto Direct Type',
+        externalId: `e2e-auto-direct-${Date.now()}`,
+        source: 'e2e-test',
+        mode: 'DIRECT',
+        currency: 'USD',
+        seller: { id: 'seller-001', name: 'Test' },
+        direct: {
+          brand: 'Auto Brand',
+          clientType: 'DIRECT_ADVERTISER',
+          approvalEmails: ['test@test.com'],
+          marketSelection: { country: 'US', currency: 'USD' },
+          budgetSetup: { currency: 'USD', budgetAmount: 5000 },
+          campaignGoal: { type: 'IMPRESSIONS', targetValue: 100000 }
+        }
+      });
+      assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+      const { data: getData } = await request('GET', `/deals/${data.result.dealId}`);
+      assert.strictEqual(getData.result.dealType, 'DIRECT');
+    });
+  });
+
+  describe('8. Inventory Assignment (via Line Item creation)', () => {
+    const inventoryTestData = { inv1Id: null, inv2Id: null, inv3Id: null };
+    
+    it('should create line item with inventories including deviceId and optional metadata.externalRefIds', async () => {
+      if (!testData.deals.guaranteed?.dealId) {
+        assert.ok(true, 'Skipping - requires prior tests');
+        return;
+      }
+      const ts = Date.now();
+      inventoryTestData.inv1Id = `inv-e2e-${ts}-001`;
+      inventoryTestData.inv2Id = `inv-e2e-${ts}-002`;
+      inventoryTestData.inv3Id = `inv-e2e-${ts}-003`;
+      
+      const lineItemPayload = {
+        externalId: `e2e-li-with-inv-${ts}`,
+        name: 'Line Item with Inventories',
+        creativeType: 'DISPLAY',
+        timezoneId: 'America/New_York',
+        startDate: '2025-01-01',
+        endDate: '2025-03-31',
+        resolutions: ['1920x1080'],
+        thresholdCountPerDay: 100,
+        programmatic: {
+          costType: 'CPM',
+          bidFloor: 5.00
+        },
+        inventories: [
+          {
+            id: inventoryTestData.inv1Id,
+            deviceId: 'device-e2e-001',
+            name: 'E2E Test Screen 1',
+            publisher: { id: 'pub-001', name: 'Test Publisher' },
+            size: '1920x1080',
+            venueType: 'RETAIL',
+            countryIso2: 'US',
+            metadata: {
+              externalRefIds: [{ source: 'LMX', externalRefId: 'lmx-e2e-001' }]
+            }
+          },
+          {
+            id: inventoryTestData.inv2Id,
+            deviceId: 'device-e2e-002',
+            name: 'E2E Test Screen 2',
+            publisher: { id: 'pub-001', name: 'Test Publisher' },
+            size: '1920x1080',
+            venueType: 'TRANSIT',
+            countryIso2: 'US',
+            metadata: {
+              externalRefIds: [
+                { source: 'LMX', externalRefId: 'lmx-e2e-002' },
+                { source: 'BROADSIGN', externalRefId: 'bs-e2e-002' }
+              ]
+            }
+          },
+          {
+            id: inventoryTestData.inv3Id,
+            deviceId: 'device-e2e-003',
+            name: 'E2E Test Screen 3 - No Metadata',
+            publisher: { id: 'pub-001', name: 'Test Publisher' },
+            size: '1920x1080',
+            venueType: 'RETAIL',
+            countryIso2: 'US'
+          }
+        ]
+      };
+      const { status, data } = await request('POST', `/deals/${testData.deals.guaranteed.dealId}/line-items`, lineItemPayload);
+      assert.strictEqual(status, 201);
+      testData.lineItems.withInventory = data.result;
+    });
+
+    it('should get inventories by line item and verify deviceId and metadata.externalRefIds are persisted', async () => {
+      if (!testData.deals.guaranteed?.dealId || !testData.lineItems.withInventory?.externalId) {
+        assert.ok(true, 'Skipping - requires prior tests');
+        return;
+      }
+      const { status, data } = await request('GET', `/deals/${testData.deals.guaranteed.dealId}/line-items/${testData.lineItems.withInventory.externalId}/inventories`);
+      assert.strictEqual(status, 200);
+      assert.ok(data.result.data.length >= 3, 'Should have at least 3 inventories');
+      
+      const inv1 = data.result.data.find(i => i.id === inventoryTestData.inv1Id);
+      const inv2 = data.result.data.find(i => i.id === inventoryTestData.inv2Id);
+      const inv3 = data.result.data.find(i => i.id === inventoryTestData.inv3Id);
+      
+      assert.ok(inv1, `Should find inventory with id ${inventoryTestData.inv1Id}`);
+      assert.ok(inv2, `Should find inventory with id ${inventoryTestData.inv2Id}`);
+      assert.ok(inv3, `Should find inventory with id ${inventoryTestData.inv3Id}`);
+      
+      // Verify deviceId persistence
+      assert.strictEqual(inv1.deviceId, 'device-e2e-001', 'Inventory 1 should have deviceId device-e2e-001');
+      assert.strictEqual(inv2.deviceId, 'device-e2e-002', 'Inventory 2 should have deviceId device-e2e-002');
+      assert.strictEqual(inv3.deviceId, 'device-e2e-003', 'Inventory 3 should have deviceId device-e2e-003');
+      
+      // Verify metadata with externalRefIds (single entry)
+      assert.ok(inv1.metadata, 'Inventory 1 should have metadata');
+      assert.ok(Array.isArray(inv1.metadata.externalRefIds), 'Inventory 1 externalRefIds should be an array');
+      assert.strictEqual(inv1.metadata.externalRefIds.length, 1, 'Inventory 1 should have 1 external ref');
+      assert.strictEqual(inv1.metadata.externalRefIds[0].source, 'LMX', 'Inventory 1 externalRefIds[0].source should be LMX');
+      assert.strictEqual(inv1.metadata.externalRefIds[0].externalRefId, 'lmx-e2e-001', 'Inventory 1 externalRefIds[0].externalRefId should be lmx-e2e-001');
+      
+      // Verify metadata with externalRefIds (multiple entries)
+      assert.ok(inv2.metadata, 'Inventory 2 should have metadata');
+      assert.ok(Array.isArray(inv2.metadata.externalRefIds), 'Inventory 2 externalRefIds should be an array');
+      assert.strictEqual(inv2.metadata.externalRefIds.length, 2, 'Inventory 2 should have 2 external refs');
+      assert.ok(inv2.metadata.externalRefIds.some(r => r.source === 'LMX'), 'Inventory 2 should have LMX ref');
+      assert.ok(inv2.metadata.externalRefIds.some(r => r.source === 'BROADSIGN'), 'Inventory 2 should have BROADSIGN ref');
+      
+      // Verify inventory without metadata is accepted (metadata is optional)
+      assert.ok(inv3, 'Inventory 3 without metadata should be created successfully');
+      assert.strictEqual(inv3.name, 'E2E Test Screen 3 - No Metadata', 'Inventory 3 should have correct name');
+      // metadata may be undefined/null or empty object - all are valid
+      const hasNoExternalRefs = !inv3.metadata || !inv3.metadata.externalRefIds || inv3.metadata.externalRefIds.length === 0;
+      assert.ok(hasNoExternalRefs, 'Inventory 3 should have no externalRefIds');
+    });
+
+    it('should allow same inventory to be assigned to multiple line items', async () => {
+      if (!testData.deals.guaranteed?.dealId) {
+        assert.ok(true, 'Skipping - requires prior tests');
+        return;
+      }
+      const sharedInventoryId = `shared-inv-${Date.now()}`;
+      
+      const li1Res = await request('POST', `/deals/${testData.deals.guaranteed.dealId}/line-items`, {
+        externalId: `e2e-li-shared-inv-1-${Date.now()}`,
+        name: 'Line Item 1 with Shared Inventory',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        thresholdCountPerDay: 50,
+        programmatic: { costType: 'CPM', bidFloor: 5.00 },
+        inventories: [{ id: sharedInventoryId, name: 'Shared Screen', size: '1920x1080' }]
+      });
+      assert.strictEqual(li1Res.status, 201, 'First line item should be created');
+      
+      const li2Res = await request('POST', `/deals/${testData.deals.guaranteed.dealId}/line-items`, {
+        externalId: `e2e-li-shared-inv-2-${Date.now()}`,
+        name: 'Line Item 2 with Shared Inventory',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        thresholdCountPerDay: 50,
+        programmatic: { costType: 'CPM', bidFloor: 5.00 },
+        inventories: [{ id: sharedInventoryId, name: 'Shared Screen', size: '1920x1080' }]
+      });
+      assert.strictEqual(li2Res.status, 201, 'Second line item with same inventory should be created');
+      
+      const inv1Res = await request('GET', `/deals/${testData.deals.guaranteed.dealId}/line-items/${li1Res.data.result.externalId}/inventories`);
+      const inv2Res = await request('GET', `/deals/${testData.deals.guaranteed.dealId}/line-items/${li2Res.data.result.externalId}/inventories`);
+      
+      assert.ok(inv1Res.data.result.data.some(i => i.id === sharedInventoryId), 'First line item should have shared inventory');
+      assert.ok(inv2Res.data.result.data.some(i => i.id === sharedInventoryId), 'Second line item should have shared inventory');
+    });
+  });
+
+  describe('9. Schedule Array Tests', () => {
+    const scheduleTestDealId = { value: null };
+
+    it('should create a deal for schedule testing', async () => {
+      const { status, data } = await request('POST', '/deals', {
+        name: 'E2E Schedule Test Deal',
+        externalId: `e2e-schedule-${Date.now()}`,
+        source: 'e2e-test',
+        mode: 'PROGRAMMATIC',
+        dealType: 'GUARANTEED',
+        currency: 'USD',
+        seller: { id: 'seller-schedule', name: 'Schedule Test Seller' },
+        programmatic: {
+          buyers: [{ id: 'buyer-schedule', name: 'Schedule Buyer' }],
+          transactionType: 'SPOT',
+          costType: 'CPM'
+        }
+      });
+      assert.strictEqual(status, 201);
+      scheduleTestDealId.value = data.result.dealId;
+    });
+
+    it('should create line item with DEFAULT schedule type', async () => {
+      const externalId = `e2e-li-schedule-default-${Date.now()}`;
+      const { status, data } = await request('POST', `/deals/${scheduleTestDealId.value}/line-items`, {
+        externalId,
+        name: 'Line Item with DEFAULT schedule',
+        creativeType: 'DISPLAY',
+        timezoneId: 'America/New_York',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        programmatic: { costType: 'CPM', bidFloor: 5.00 },
+        thresholdCountPerDay: 50,
+        schedule: [
+          {
+            type: 'DEFAULT',
+            priority: 1,
+            hours: [{ start: 6, end: 22 }]
+          }
+        ]
+      });
+      assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+      
+      const getRes = await request('GET', `/deals/${scheduleTestDealId.value}/line-items/${externalId}`);
+      assert.strictEqual(getRes.status, 200);
+      assert.ok(getRes.data.result.schedule, 'Expected schedule in response');
+      assert.strictEqual(getRes.data.result.schedule[0].type, 'DEFAULT');
+    });
+
+    it('should create line item with WEEKDAY schedule type', async () => {
+      const externalId = `e2e-li-schedule-weekday-${Date.now()}`;
+      const { status, data } = await request('POST', `/deals/${scheduleTestDealId.value}/line-items`, {
+        externalId,
+        name: 'Line Item with WEEKDAY schedule',
+        creativeType: 'DISPLAY',
+        timezoneId: 'Europe/London',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        programmatic: { costType: 'CPM', bidFloor: 6.00 },
+        thresholdCountPerDay: 50,
+        schedule: [
+          {
+            type: 'WEEKDAY',
+            priority: 2,
+            daysOfWeek: [1, 2, 3, 4, 5],
+            hours: [{ start: 8, end: 18 }]
+          }
+        ]
+      });
+      assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+      
+      const getRes = await request('GET', `/deals/${scheduleTestDealId.value}/line-items/${externalId}`);
+      assert.strictEqual(getRes.data.result.schedule[0].type, 'WEEKDAY');
+      assert.deepStrictEqual(getRes.data.result.schedule[0].daysOfWeek, [1, 2, 3, 4, 5]);
+    });
+
+    it('should create line item with WEEKEND schedule type', async () => {
+      const externalId = `e2e-li-schedule-weekend-${Date.now()}`;
+      const { status, data } = await request('POST', `/deals/${scheduleTestDealId.value}/line-items`, {
+        externalId,
+        name: 'Line Item with WEEKEND schedule',
+        creativeType: 'DISPLAY',
+        timezoneId: 'Asia/Tokyo',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        programmatic: { costType: 'CPM', bidFloor: 7.00 },
+        thresholdCountPerDay: 50,
+        schedule: [
+          {
+            type: 'WEEKEND',
+            priority: 3,
+            daysOfWeek: [6, 7],
+            hours: [{ start: 10, end: 20 }]
+          }
+        ]
+      });
+      assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+      
+      const getRes = await request('GET', `/deals/${scheduleTestDealId.value}/line-items/${externalId}`);
+      assert.strictEqual(getRes.data.result.schedule[0].type, 'WEEKEND');
+      assert.deepStrictEqual(getRes.data.result.schedule[0].daysOfWeek, [6, 7]);
+    });
+
+    it('should create line item with CUSTOM schedule type (specific date)', async () => {
+      const externalId = `e2e-li-schedule-custom-${Date.now()}`;
+      const { status, data } = await request('POST', `/deals/${scheduleTestDealId.value}/line-items`, {
+        externalId,
+        name: 'Line Item with CUSTOM schedule',
+        creativeType: 'DISPLAY',
+        timezoneId: 'America/Chicago',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        programmatic: { costType: 'CPM', bidFloor: 8.00 },
+        thresholdCountPerDay: 50,
+        schedule: [
+          {
+            type: 'CUSTOM',
+            date: '2025-07-04',
+            priority: 10,
+            hours: [{ start: 0, end: 23 }]
+          }
+        ]
+      });
+      assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+      
+      const getRes = await request('GET', `/deals/${scheduleTestDealId.value}/line-items/${externalId}`);
+      assert.strictEqual(getRes.data.result.schedule[0].type, 'CUSTOM');
+      assert.strictEqual(getRes.data.result.schedule[0].date, '2025-07-04');
+    });
+
+    it('should create line item with multiple schedule entries (mixed types)', async () => {
+      const externalId = `e2e-li-schedule-mixed-${Date.now()}`;
+      const { status, data } = await request('POST', `/deals/${scheduleTestDealId.value}/line-items`, {
+        externalId,
+        name: 'Line Item with mixed schedules',
+        creativeType: 'DISPLAY',
+        timezoneId: 'America/Los_Angeles',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        programmatic: { costType: 'CPM', bidFloor: 9.00 },
+        thresholdCountPerDay: 50,
+        schedule: [
+          {
+            type: 'DEFAULT',
+            priority: 1,
+            hours: [{ start: 8, end: 20 }]
+          },
+          {
+            type: 'WEEKDAY',
+            priority: 5,
+            daysOfWeek: [1, 2, 3, 4, 5],
+            hours: [{ start: 7, end: 19 }]
+          },
+          {
+            type: 'WEEKEND',
+            priority: 5,
+            daysOfWeek: [6, 7],
+            hours: [{ start: 10, end: 22 }]
+          },
+          {
+            type: 'CUSTOM',
+            date: '2025-12-25',
+            priority: 100,
+            hours: [{ start: 0, end: 12 }]
+          }
+        ]
+      });
+      assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+      
+      const getRes = await request('GET', `/deals/${scheduleTestDealId.value}/line-items/${externalId}`);
+      assert.strictEqual(getRes.data.result.schedule.length, 4);
+      const types = getRes.data.result.schedule.map(s => s.type);
+      assert.ok(types.includes('DEFAULT'));
+      assert.ok(types.includes('WEEKDAY'));
+      assert.ok(types.includes('WEEKEND'));
+      assert.ok(types.includes('CUSTOM'));
+    });
+
+    it('should update line item schedule', async () => {
+      const createRes = await request('POST', `/deals/${scheduleTestDealId.value}/line-items`, {
+        externalId: `e2e-li-schedule-update-${Date.now()}`,
+        name: 'Line Item to update schedule',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        programmatic: { costType: 'CPM', bidFloor: 5.00 },
+        thresholdCountPerDay: 50,
+        schedule: [
+          { type: 'DEFAULT', priority: 1, hours: [{ start: 0, end: 23 }] }
+        ]
+      });
+      assert.strictEqual(createRes.status, 201);
+
+      const { status, data } = await request('PUT', `/deals/${scheduleTestDealId.value}/line-items/${createRes.data.result.externalId}`, {
+        schedule: [
+          { type: 'WEEKDAY', priority: 2, daysOfWeek: [1, 2, 3, 4, 5], hours: [{ start: 9, end: 17 }] },
+          { type: 'WEEKEND', priority: 2, daysOfWeek: [6, 7], hours: [{ start: 12, end: 18 }] }
+        ]
+      });
+      assert.strictEqual(status, 200, `Failed: ${JSON.stringify(data)}`);
+
+      const getRes = await request('GET', `/deals/${scheduleTestDealId.value}/line-items/${createRes.data.result.externalId}`);
+      assert.strictEqual(getRes.data.result.schedule.length, 2);
+    });
+
+    it('should create line item with schedule with validity window', async () => {
+      const externalId = `e2e-li-schedule-validity-${Date.now()}`;
+      const { status, data } = await request('POST', `/deals/${scheduleTestDealId.value}/line-items`, {
+        externalId,
+        name: 'Line Item with schedule validity',
+        creativeType: 'DISPLAY',
+        timezoneId: 'America/New_York',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        programmatic: { costType: 'CPM', bidFloor: 5.00 },
+        thresholdCountPerDay: 50,
+        schedule: [
+          {
+            type: 'DEFAULT',
+            priority: 1,
+            validity: { startDate: '2025-06-01', endDate: '2025-08-31' },
+            hours: [{ start: 6, end: 22 }]
+          }
+        ]
+      });
+      assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+      
+      const getRes = await request('GET', `/deals/${scheduleTestDealId.value}/line-items/${externalId}`);
+      assert.ok(getRes.data.result.schedule[0].validity);
+      assert.strictEqual(getRes.data.result.schedule[0].validity.startDate, '2025-06-01');
+      assert.strictEqual(getRes.data.result.schedule[0].validity.endDate, '2025-08-31');
+    });
+
+    it('should archive schedule test deal', async () => {
+      const { status } = await request('DELETE', `/deals/${scheduleTestDealId.value}`);
+      assert.ok([200, 404].includes(status));
+    });
+  });
+
+  describe('10. Auto-Calculation Edge Tests', () => {
+    const autoCalcDealId = { value: null };
+
+    it('should create a deal for auto-calculation testing', async () => {
+      const { status, data } = await request('POST', '/deals', {
+        name: 'E2E Auto-Calc Test Deal',
+        externalId: `e2e-autocalc-${Date.now()}`,
+        source: 'e2e-test',
+        mode: 'PROGRAMMATIC',
+        dealType: 'GUARANTEED',
+        currency: 'USD',
+        seller: { id: 'seller-autocalc', name: 'Auto Calc Seller' },
+        programmatic: {
+          buyers: [{ id: 'buyer-autocalc', name: 'Auto Calc Buyer' }],
+          transactionType: 'SPOT',
+          costType: 'CPM'
+        }
+      });
+      assert.strictEqual(status, 201);
+      autoCalcDealId.value = data.result.dealId;
+    });
+
+    it('should auto-calculate deal dates from line items', async () => {
+      await request('POST', `/deals/${autoCalcDealId.value}/line-items`, {
+        externalId: `e2e-li-autocalc-1-${Date.now()}`,
+        name: 'Line Item 1 for auto-calc',
+        creativeType: 'DISPLAY',
+        timezoneId: 'America/New_York',
+        startDate: '2025-03-15',
+        endDate: '2025-06-30',
+        resolutions: ['1920x1080'],
+        thresholdCountPerDay: 50,
+        programmatic: { costType: 'CPM', bidFloor: 5.00 }
+      });
+      
+      await request('POST', `/deals/${autoCalcDealId.value}/line-items`, {
+        externalId: `e2e-li-autocalc-2-${Date.now()}`,
+        name: 'Line Item 2 for auto-calc',
+        creativeType: 'DISPLAY',
+        timezoneId: 'America/New_York',
+        startDate: '2025-01-01',
+        endDate: '2025-04-30',
+        resolutions: ['1920x1080'],
+        thresholdCountPerDay: 50,
+        programmatic: { costType: 'CPM', bidFloor: 6.00 }
+      });
+
+      const { status, data } = await request('GET', `/deals/${autoCalcDealId.value}`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.startDate, '2025-01-01', 'Deal startDate should be earliest line item startDate');
+      assert.strictEqual(data.result.endDate, '2025-06-30', 'Deal endDate should be latest line item endDate');
+    });
+
+    it('should auto-calculate lineItemsCount from active line items', async () => {
+      const { status, data } = await request('GET', `/deals/${autoCalcDealId.value}`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.lineItemsCount, 2, 'lineItemsCount should equal number of active line items');
+    });
+
+    it('should auto-calculate timezoneId from first line item', async () => {
+      const { status, data } = await request('GET', `/deals/${autoCalcDealId.value}`);
+      assert.strictEqual(status, 200);
+      assert.ok(data.result.timezoneId, 'Deal should have auto-calculated timezoneId');
+    });
+
+    it('should auto-calculate unique publishers count from line item inventories', async () => {
+      const ts = Date.now();
+      const liRes = await request('POST', `/deals/${autoCalcDealId.value}/line-items`, {
+        externalId: `e2e-li-autocalc-inv-${ts}`,
+        name: 'Line Item with inventories for publisher count',
+        creativeType: 'DISPLAY',
+        timezoneId: 'America/Chicago',
+        startDate: '2025-02-01',
+        endDate: '2025-05-31',
+        resolutions: ['1920x1080'],
+        thresholdCountPerDay: 50,
+        programmatic: { costType: 'CPM', bidFloor: 5.00 },
+        inventories: [
+          { id: `inv-ac-1-${ts}`, name: 'Screen 1', publisher: { id: 'pub-001', name: 'Publisher A' }, size: '1920x1080' },
+          { id: `inv-ac-2-${ts}`, name: 'Screen 2', publisher: { id: 'pub-002', name: 'Publisher B' }, size: '1920x1080' },
+          { id: `inv-ac-3-${ts}`, name: 'Screen 3', publisher: { id: 'pub-001', name: 'Publisher A' }, size: '1920x1080' }
+        ]
+      });
+      assert.strictEqual(liRes.status, 201, `Failed: ${JSON.stringify(liRes.data)}`);
+
+      const { status, data } = await request('GET', `/deals/${autoCalcDealId.value}`);
+      assert.strictEqual(status, 200);
+      assert.ok(data.result.publishers !== undefined, 'Deal should have publishers field');
+      assert.ok(Array.isArray(data.result.publishers), 'Publishers should be an array');
+      assert.ok(data.result.publishers.length >= 2, `Publishers count should be at least 2 unique publishers, got: ${data.result.publishers.length}`);
+    });
+
+    it('should auto-calculate programmatic metrics from line items', async () => {
+      const li1 = await request('POST', `/deals/${autoCalcDealId.value}/line-items`, {
+        externalId: `e2e-li-metrics-1-${Date.now()}`,
+        name: 'Metrics Line Item 1',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-03-31',
+        resolutions: ['1920x1080'],
+        thresholdCountPerDay: 50,
+        programmatic: { costType: 'CPM', bidFloor: 10.00, deliveryGoal: 100000, netCost: 1000 }
+      });
+      
+      const li2 = await request('POST', `/deals/${autoCalcDealId.value}/line-items`, {
+        externalId: `e2e-li-metrics-2-${Date.now()}`,
+        name: 'Metrics Line Item 2',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-03-31',
+        resolutions: ['1920x1080'],
+        thresholdCountPerDay: 50,
+        programmatic: { costType: 'CPM', bidFloor: 15.00, deliveryGoal: 200000, netCost: 3000 }
+      });
+      
+      assert.strictEqual(li1.status, 201);
+      assert.strictEqual(li2.status, 201);
+
+      const { status, data } = await request('GET', `/deals/${autoCalcDealId.value}`);
+      assert.strictEqual(status, 200);
+      assert.ok(data.result.programmatic, 'Deal should have programmatic object');
+      assert.ok(data.result.programmatic.deliveryGoal >= 300000, 'Aggregated deliveryGoal should be at least 300,000');
+      assert.ok(data.result.programmatic.netCost >= 4000, 'Aggregated netCost should be at least 4,000');
+    });
+
+    it('should update deal auto-calculated fields when line item is archived', async () => {
+      const liRes = await request('POST', `/deals/${autoCalcDealId.value}/line-items`, {
+        externalId: `e2e-li-archive-test-${Date.now()}`,
+        name: 'Line Item to Archive',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        thresholdCountPerDay: 50,
+        programmatic: { costType: 'CPM', bidFloor: 5.00 }
+      });
+      assert.strictEqual(liRes.status, 201);
+
+      const beforeArchive = await request('GET', `/deals/${autoCalcDealId.value}`);
+      const countBefore = beforeArchive.data.result.lineItemsCount;
+
+      await request('DELETE', `/deals/${autoCalcDealId.value}/line-items/${liRes.data.result.externalId}`);
+
+      const afterArchive = await request('GET', `/deals/${autoCalcDealId.value}`);
+      assert.strictEqual(afterArchive.data.result.lineItemsCount, countBefore - 1, 'lineItemsCount should decrease after archiving line item');
+    });
+
+    it('should archive auto-calculation test deal', async () => {
+      const { status } = await request('DELETE', `/deals/${autoCalcDealId.value}`);
+      assert.ok([200, 404].includes(status));
+    });
+  });
+
+  describe('11. DIRECT Targeting Edge Cases', () => {
+    const targetingDealId = { value: null };
+
+    it('should create DIRECT deal for targeting edge tests', async () => {
+      const { status, data } = await request('POST', '/deals', {
+        name: 'Targeting Edge Test Deal',
+        externalId: `e2e-targeting-edge-${Date.now()}`,
+        source: 'e2e-test',
+        mode: 'DIRECT',
+        dealType: 'DIRECT',
+        currency: 'MYR',
+        seller: { id: 'seller-001', name: 'Test Seller' },
+        direct: {
+          brand: 'Targeting Test Brand',
+          clientType: 'DIRECT_ADVERTISER',
+          approvalEmails: ['test@example.com'],
+          marketSelection: { country: 'MY', currency: 'MYR' },
+          budgetSetup: { currency: 'MYR', budgetAmount: 50000 },
+          campaignGoal: { type: 'IMPRESSIONS', targetValue: 100000 }
+        }
+      });
+      assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+      targetingDealId.value = data.result.dealId;
+    });
+
+    it('should accept DIRECT line item with empty targeting object', async () => {
+      if (!targetingDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const { status, data } = await request('POST', `/deals/${targetingDealId.value}/line-items`, {
+        externalId: `e2e-li-empty-targeting-${Date.now()}`,
+        name: 'Line Item with Empty Targeting',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        targeting: {}
+      });
+      assert.strictEqual(status, 201, `Should accept empty targeting: ${JSON.stringify(data)}`);
+    });
+
+    it('should accept DIRECT line item with partial demographics', async () => {
+      if (!targetingDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const { status, data } = await request('POST', `/deals/${targetingDealId.value}/line-items`, {
+        externalId: `e2e-li-partial-demo-${Date.now()}`,
+        name: 'Line Item with Partial Demographics',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        targeting: {
+          demographics: { ageGroups: ['25-34'] }
+        }
+      });
+      assert.strictEqual(status, 201, `Should accept partial demographics: ${JSON.stringify(data)}`);
+    });
+
+    it('should reject DIRECT line item with invalid gender value', async () => {
+      if (!targetingDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const { status } = await request('POST', `/deals/${targetingDealId.value}/line-items`, {
+        externalId: `e2e-li-invalid-gender-${Date.now()}`,
+        name: 'Line Item with Invalid Gender',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        targeting: {
+          demographics: { genders: ['invalid_gender'] }
+        }
+      });
+      assert.strictEqual(status, 400, 'Should reject invalid gender value');
+    });
+
+    it('should accept DIRECT line item with venueTypes using dot-notation', async () => {
+      if (!targetingDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const { status, data } = await request('POST', `/deals/${targetingDealId.value}/line-items`, {
+        externalId: `e2e-li-venue-dot-${Date.now()}`,
+        name: 'Line Item with Dot-Notation VenueTypes',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        targeting: {
+          venueTypes: ['transit.train_stations.platform', 'retail.shopping_mall.atrium', 'entertainment.cinema']
+        }
+      });
+      assert.strictEqual(status, 201, `Should accept dot-notation venueTypes: ${JSON.stringify(data)}`);
+    });
+
+    it('should accept DIRECT line item with geofencing polygon (exclusion zone)', async () => {
+      if (!targetingDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const { status, data } = await request('POST', `/deals/${targetingDealId.value}/line-items`, {
+        externalId: `e2e-li-geofence-excl-${Date.now()}`,
+        name: 'Line Item with Exclusion Geofencing',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        targeting: {
+          geofencing: {
+            geometrics: [
+              { type: 'Polygon', coordinates: [[[-118.25, 34.04], [-118.24, 34.04], [-118.24, 34.05], [-118.25, 34.05], [-118.25, 34.04]]], included: true },
+              { type: 'Polygon', coordinates: [[[-118.245, 34.045], [-118.244, 34.045], [-118.244, 34.046], [-118.245, 34.046], [-118.245, 34.045]]], included: false }
+            ]
+          }
+        }
+      });
+      assert.strictEqual(status, 201, `Should accept exclusion geofencing: ${JSON.stringify(data)}`);
+    });
+
+    it('should reject DIRECT line item with invalid geometry type', async () => {
+      if (!targetingDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const { status } = await request('POST', `/deals/${targetingDealId.value}/line-items`, {
+        externalId: `e2e-li-invalid-geo-${Date.now()}`,
+        name: 'Line Item with Invalid Geometry',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        targeting: {
+          geofencing: {
+            geometrics: [{ type: 'InvalidShape', coordinates: [[0, 0]] }]
+          }
+        }
+      });
+      assert.strictEqual(status, 400, 'Should reject invalid geometry type');
+    });
+
+    it('should accept DIRECT line item with POIs in geofencing geometry', async () => {
+      if (!targetingDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const externalId = `e2e-li-pois-${Date.now()}`;
+      const { status, data } = await request('POST', `/deals/${targetingDealId.value}/line-items`, {
+        externalId,
+        name: 'Line Item with POIs',
+        creativeType: 'DISPLAY',
+        timezoneId: 'Asia/Tokyo',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        targeting: {
+          geofencing: {
+            geometrics: [{
+              type: 'Polygon',
+              coordinates: [[[139.668, 35.698], [139.801, 35.698], [139.801, 35.655], [139.668, 35.655], [139.668, 35.698]]],
+              included: true,
+              pois: [
+                { type: 'cafe', label: 'Cafe' },
+                { type: 'restaurant', label: 'Restaurant' },
+                { type: 'shopping_mall', label: 'Shopping Mall' },
+                { type: 'school', label: 'School' }
+              ]
+            }]
+          }
+        }
+      });
+      assert.strictEqual(status, 201, `Should accept POIs: ${JSON.stringify(data)}`);
+      
+      const getRes = await request('GET', `/deals/${targetingDealId.value}/line-items/${externalId}`);
+      assert.ok(getRes.data.result.targeting.geofencing.geometrics[0].pois, 'Should have POIs');
+      assert.strictEqual(getRes.data.result.targeting.geofencing.geometrics[0].pois.length, 4, 'Should have 4 POIs');
+      assert.strictEqual(getRes.data.result.targeting.geofencing.geometrics[0].pois[0].type, 'cafe');
+    });
+
+    it('should accept geometry with empty POIs array', async () => {
+      if (!targetingDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const { status, data } = await request('POST', `/deals/${targetingDealId.value}/line-items`, {
+        externalId: `e2e-li-empty-pois-${Date.now()}`,
+        name: 'Line Item with Empty POIs',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        targeting: {
+          geofencing: {
+            geometrics: [{
+              type: 'Polygon',
+              coordinates: [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]],
+              included: true,
+              pois: []
+            }]
+          }
+        }
+      });
+      assert.strictEqual(status, 201, `Should accept empty POIs array: ${JSON.stringify(data)}`);
+    });
+
+    it('should accept geometry without POIs field (optional)', async () => {
+      if (!targetingDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const { status, data } = await request('POST', `/deals/${targetingDealId.value}/line-items`, {
+        externalId: `e2e-li-no-pois-${Date.now()}`,
+        name: 'Line Item without POIs',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        targeting: {
+          geofencing: {
+            geometrics: [{
+              type: 'Polygon',
+              coordinates: [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]],
+              included: true
+            }]
+          }
+        }
+      });
+      assert.strictEqual(status, 201, `Should accept geometry without POIs: ${JSON.stringify(data)}`);
+    });
+
+    it('should reject POI missing type field', async () => {
+      if (!targetingDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const { status } = await request('POST', `/deals/${targetingDealId.value}/line-items`, {
+        externalId: `e2e-li-poi-no-type-${Date.now()}`,
+        name: 'Line Item with POI missing type',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        targeting: {
+          geofencing: {
+            geometrics: [{
+              type: 'Polygon',
+              coordinates: [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]],
+              pois: [{ label: 'Missing Type' }]
+            }]
+          }
+        }
+      });
+      assert.strictEqual(status, 400, 'Should reject POI missing type field');
+    });
+
+    it('should reject POI missing label field', async () => {
+      if (!targetingDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const { status } = await request('POST', `/deals/${targetingDealId.value}/line-items`, {
+        externalId: `e2e-li-poi-no-label-${Date.now()}`,
+        name: 'Line Item with POI missing label',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        targeting: {
+          geofencing: {
+            geometrics: [{
+              type: 'Polygon',
+              coordinates: [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]],
+              pois: [{ type: 'cafe' }]
+            }]
+          }
+        }
+      });
+      assert.strictEqual(status, 400, 'Should reject POI missing label field');
+    });
+
+    it('should accept multiple geometrics with different POIs', async () => {
+      if (!targetingDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const externalId = `e2e-li-multi-geo-pois-${Date.now()}`;
+      const { status, data } = await request('POST', `/deals/${targetingDealId.value}/line-items`, {
+        externalId,
+        name: 'Line Item with Multiple Geometries and POIs',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        targeting: {
+          geofencing: {
+            geometrics: [
+              {
+                type: 'Polygon',
+                coordinates: [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]],
+                included: true,
+                pois: [{ type: 'cafe', label: 'Coffee Shops' }, { type: 'restaurant', label: 'Restaurants' }]
+              },
+              {
+                type: 'Polygon',
+                coordinates: [[[2, 2], [3, 2], [3, 3], [2, 3], [2, 2]]],
+                included: true,
+                pois: [{ type: 'gym', label: 'Fitness Centers' }, { type: 'hospital', label: 'Hospitals' }]
+              },
+              {
+                type: 'Polygon',
+                coordinates: [[[4, 4], [5, 4], [5, 5], [4, 5], [4, 4]]],
+                included: false
+              }
+            ]
+          }
+        }
+      });
+      assert.strictEqual(status, 201, `Should accept multiple geometrics with POIs: ${JSON.stringify(data)}`);
+      
+      const getRes = await request('GET', `/deals/${targetingDealId.value}/line-items/${externalId}`);
+      assert.strictEqual(getRes.data.result.targeting.geofencing.geometrics.length, 3);
+      assert.strictEqual(getRes.data.result.targeting.geofencing.geometrics[0].pois.length, 2);
+      assert.strictEqual(getRes.data.result.targeting.geofencing.geometrics[1].pois.length, 2);
+      assert.ok(!getRes.data.result.targeting.geofencing.geometrics[2].pois || getRes.data.result.targeting.geofencing.geometrics[2].pois.length === 0, 'Third geometry should have no POIs');
+    });
+
+    it('should update POIs on existing line item', async () => {
+      if (!targetingDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const externalId = `e2e-li-update-pois-${Date.now()}`;
+      const createRes = await request('POST', `/deals/${targetingDealId.value}/line-items`, {
+        externalId,
+        name: 'Line Item for POI Update',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        targeting: {
+          geofencing: {
+            geometrics: [{
+              type: 'Polygon',
+              coordinates: [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]],
+              included: true,
+              pois: [{ type: 'cafe', label: 'Cafe' }]
+            }]
+          }
+        }
+      });
+      assert.strictEqual(createRes.status, 201);
+      
+      const { status, data } = await request('PUT', `/deals/${targetingDealId.value}/line-items/${externalId}`, {
+        targeting: {
+          geofencing: {
+            geometrics: [{
+              type: 'Polygon',
+              coordinates: [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]],
+              included: true,
+              pois: [
+                { type: 'restaurant', label: 'Restaurant' },
+                { type: 'bar', label: 'Bar' },
+                { type: 'nightclub', label: 'Nightclub' }
+              ]
+            }]
+          }
+        }
+      });
+      assert.strictEqual(status, 200, `POI update failed: ${JSON.stringify(data)}`);
+      
+      const getRes = await request('GET', `/deals/${targetingDealId.value}/line-items/${externalId}`);
+      assert.strictEqual(getRes.data.result.targeting.geofencing.geometrics[0].pois.length, 3, 'Should have 3 updated POIs');
+      assert.strictEqual(getRes.data.result.targeting.geofencing.geometrics[0].pois[0].type, 'restaurant');
+    });
+
+    it('should accept DIRECT line item with weather-based deliveryTargeting', async () => {
+      if (!targetingDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const { status, data } = await request('POST', `/deals/${targetingDealId.value}/line-items`, {
+        externalId: `e2e-li-weather-${Date.now()}`,
+        name: 'Line Item with Weather Targeting',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        deliveryTargeting: {
+          signals: {
+            weather: {
+              conditions: ['rainy', 'stormy'],
+              temperature: { min: 10, max: 25, unit: 'celsius' }
+            }
+          }
+        }
+      });
+      assert.strictEqual(status, 201, `Should accept weather deliveryTargeting: ${JSON.stringify(data)}`);
+    });
+
+    it('should reject DIRECT line item with invalid temperature unit', async () => {
+      if (!targetingDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const { status } = await request('POST', `/deals/${targetingDealId.value}/line-items`, {
+        externalId: `e2e-li-invalid-temp-${Date.now()}`,
+        name: 'Line Item with Invalid Temp Unit',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        deliveryTargeting: {
+          signals: {
+            weather: {
+              temperature: { min: 0, max: 100, unit: 'kelvin' }
+            }
+          }
+        }
+      });
+      assert.strictEqual(status, 400, 'Should reject invalid temperature unit');
+    });
+
+    it('should accept DIRECT line item with metadata version tracking', async () => {
+      if (!targetingDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const { status, data } = await request('POST', `/deals/${targetingDealId.value}/line-items`, {
+        externalId: `e2e-li-metadata-${Date.now()}`,
+        name: 'Line Item with Metadata Version',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        metadata: {
+          inventoryFilteredBy: ['demographics', 'venueTypes'],
+          deliveryTriggeredBy: ['weather'],
+          venueTaxonomyFormat: 'dot-notation',
+          version: '2.0.1'
+        }
+      });
+      assert.strictEqual(status, 201, `Should accept metadata: ${JSON.stringify(data)}`);
+    });
+
+    it('should reject DIRECT line item with invalid inventoryFilteredBy value', async () => {
+      if (!targetingDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const { status } = await request('POST', `/deals/${targetingDealId.value}/line-items`, {
+        externalId: `e2e-li-invalid-filter-${Date.now()}`,
+        name: 'Line Item with Invalid Filter',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        metadata: {
+          inventoryFilteredBy: ['invalid_filter_type']
+        }
+      });
+      assert.strictEqual(status, 400, 'Should reject invalid inventoryFilteredBy');
+    });
+
+    it('should reject DIRECT line item with invalid venueTaxonomyFormat', async () => {
+      if (!targetingDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const { status } = await request('POST', `/deals/${targetingDealId.value}/line-items`, {
+        externalId: `e2e-li-invalid-taxonomy-${Date.now()}`,
+        name: 'Line Item with Invalid Taxonomy Format',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        metadata: {
+          venueTaxonomyFormat: 'unsupported_format'
+        }
+      });
+      assert.strictEqual(status, 400, 'Should reject invalid venueTaxonomyFormat');
+    });
+
+    it('should accept partial update of targeting only', async () => {
+      if (!targetingDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const createRes = await request('POST', `/deals/${targetingDealId.value}/line-items`, {
+        externalId: `e2e-li-partial-update-${Date.now()}`,
+        name: 'Line Item for Partial Update',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        targeting: { demographics: { ageGroups: ['18-24'] } }
+      });
+      assert.strictEqual(createRes.status, 201);
+
+      const { status, data } = await request('PUT', `/deals/${targetingDealId.value}/line-items/${createRes.data.result.externalId}`, {
+        targeting: { demographics: { ageGroups: ['25-34', '35-44'] }, venueTypes: ['retail'] }
+      });
+      assert.strictEqual(status, 200, `Partial targeting update failed: ${JSON.stringify(data)}`);
+      
+      const getRes = await request('GET', `/deals/${targetingDealId.value}/line-items/${createRes.data.result.externalId}`);
+      assert.ok(getRes.data.result.targeting.demographics.ageGroups.includes('25-34'), 'Targeting should be updated');
+      assert.ok(getRes.data.result.targeting.venueTypes.includes('retail'), 'VenueTypes should be added');
+    });
+
+    it('should accept DIRECT line item with POIs in locations', async () => {
+      if (!targetingDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const { status, data } = await request('POST', `/deals/${targetingDealId.value}/line-items`, {
+        externalId: `e2e-li-location-pois-${Date.now()}`,
+        name: 'Line Item with Location POIs',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        targeting: {
+          geofencing: {
+            locations: [{
+              name: 'Tokyo Station',
+              lat: 35.6812,
+              lng: 139.7671,
+              radius: 1000,
+              address: 'Tokyo, Japan',
+              included: true,
+              pois: [
+                { type: 'train_station', label: 'Train Station' },
+                { type: 'shopping_mall', label: 'Shopping Mall' },
+                { type: 'restaurant', label: 'Restaurant' }
+              ]
+            }]
+          }
+        }
+      });
+      assert.strictEqual(status, 201, `Should accept location POIs: ${JSON.stringify(data)}`);
+      
+      const getRes = await request('GET', `/deals/${targetingDealId.value}/line-items/${data.result.externalId}`);
+      assert.ok(getRes.data.result.targeting.geofencing.locations, 'Should have locations');
+      assert.ok(getRes.data.result.targeting.geofencing.locations[0].pois, 'Should have POIs in location');
+      assert.strictEqual(getRes.data.result.targeting.geofencing.locations[0].pois.length, 3, 'Should have 3 POIs');
+      assert.strictEqual(getRes.data.result.targeting.geofencing.locations[0].pois[0].type, 'train_station');
+    });
+
+    it('should accept location with empty POIs array', async () => {
+      if (!targetingDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const { status, data } = await request('POST', `/deals/${targetingDealId.value}/line-items`, {
+        externalId: `e2e-li-location-empty-pois-${Date.now()}`,
+        name: 'Line Item with Empty Location POIs',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        targeting: {
+          geofencing: {
+            locations: [{
+              name: 'Osaka Station',
+              lat: 34.7021,
+              lng: 135.4960,
+              radius: 500,
+              included: true,
+              pois: []
+            }]
+          }
+        }
+      });
+      assert.strictEqual(status, 201, `Should accept empty POIs array: ${JSON.stringify(data)}`);
+    });
+
+    it('should accept location without POIs field (optional)', async () => {
+      if (!targetingDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const { status, data } = await request('POST', `/deals/${targetingDealId.value}/line-items`, {
+        externalId: `e2e-li-location-no-pois-${Date.now()}`,
+        name: 'Line Item with No POIs Field',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        targeting: {
+          geofencing: {
+            locations: [{
+              name: 'Kyoto Station',
+              lat: 34.9858,
+              lng: 135.7587,
+              radius: 800,
+              included: true
+            }]
+          }
+        }
+      });
+      assert.strictEqual(status, 201, `Should accept without POIs field: ${JSON.stringify(data)}`);
+    });
+
+    it('should reject location POI missing type field', async () => {
+      if (!targetingDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const { status } = await request('POST', `/deals/${targetingDealId.value}/line-items`, {
+        externalId: `e2e-li-location-poi-no-type-${Date.now()}`,
+        name: 'Line Item with Invalid POI',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        targeting: {
+          geofencing: {
+            locations: [{
+              lat: 35.0,
+              lng: 135.0,
+              radius: 500,
+              pois: [{ label: 'Missing Type' }]
+            }]
+          }
+        }
+      });
+      assert.strictEqual(status, 400, 'Should reject POI missing type');
+    });
+
+    it('should reject location POI missing label field', async () => {
+      if (!targetingDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const { status } = await request('POST', `/deals/${targetingDealId.value}/line-items`, {
+        externalId: `e2e-li-location-poi-no-label-${Date.now()}`,
+        name: 'Line Item with Invalid POI',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        targeting: {
+          geofencing: {
+            locations: [{
+              lat: 35.0,
+              lng: 135.0,
+              radius: 500,
+              pois: [{ type: 'cafe' }]
+            }]
+          }
+        }
+      });
+      assert.strictEqual(status, 400, 'Should reject POI missing label');
+    });
+
+    it('should archive targeting edge test deal', async () => {
+      if (!targetingDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const { status } = await request('DELETE', `/deals/${targetingDealId.value}`);
+      assert.ok([200, 404].includes(status));
+    });
+  });
+
+  describe('12. Optional ApprovalEmails for DIRECT Mode', () => {
+    it('should create DIRECT deal without approvalEmails', async () => {
+      const { status, data } = await request('POST', '/deals', {
+        name: 'Direct Deal No Approval Emails',
+        externalId: `e2e-no-approval-${Date.now()}`,
+        source: 'e2e-test',
+        mode: 'DIRECT',
+        dealType: 'DIRECT',
+        brand: 'TestBrand',
+        clientType: 'DIRECT_ADVERTISER',
+        currency: 'USD',
+        marketSelection: { country: 'US', currency: 'USD' },
+        budgetSetup: { currency: 'USD', budgetAmount: 10000, budgetType: 'TOTAL' },
+        campaignGoal: { type: 'IMPRESSIONS', targetValue: 100000 }
+      });
+      assert.strictEqual(status, 201, `Should create DIRECT deal without approvalEmails: ${JSON.stringify(data)}`);
+      
+      await request('DELETE', `/deals/${data.result.dealId}`);
+    });
+
+    it('should create DIRECT deal with empty approvalEmails array', async () => {
+      const { status, data } = await request('POST', '/deals', {
+        name: 'Direct Deal Empty Approval Emails',
+        externalId: `e2e-empty-approval-${Date.now()}`,
+        source: 'e2e-test',
+        mode: 'DIRECT',
+        dealType: 'DIRECT',
+        brand: 'TestBrand',
+        clientType: 'DIRECT_ADVERTISER',
+        currency: 'USD',
+        approvalEmails: [],
+        marketSelection: { country: 'US', currency: 'USD' },
+        budgetSetup: { currency: 'USD', budgetAmount: 10000, budgetType: 'TOTAL' },
+        campaignGoal: { type: 'IMPRESSIONS', targetValue: 100000 }
+      });
+      assert.strictEqual(status, 201, `Should create DIRECT deal with empty approvalEmails: ${JSON.stringify(data)}`);
+      
+      await request('DELETE', `/deals/${data.result.dealId}`);
+    });
+
+    it('should create DIRECT deal with approvalEmails', async () => {
+      const { status, data } = await request('POST', '/deals', {
+        name: 'Direct Deal With Approval Emails',
+        externalId: `e2e-with-approval-${Date.now()}`,
+        source: 'e2e-test',
+        mode: 'DIRECT',
+        dealType: 'DIRECT',
+        brand: 'TestBrand',
+        clientType: 'DIRECT_ADVERTISER',
+        currency: 'USD',
+        approvalEmails: ['test@example.com', 'approver@example.com'],
+        marketSelection: { country: 'US', currency: 'USD' },
+        budgetSetup: { currency: 'USD', budgetAmount: 10000, budgetType: 'TOTAL' },
+        campaignGoal: { type: 'IMPRESSIONS', targetValue: 100000 }
+      });
+      assert.strictEqual(status, 201, `Should create DIRECT deal with approvalEmails: ${JSON.stringify(data)}`);
+      
+      const getRes = await request('GET', `/deals/${data.result.dealId}`);
+      assert.strictEqual(getRes.status, 200, 'Should get deal');
+      assert.ok(getRes.data.result.direct, 'Should have direct object');
+      assert.ok(Array.isArray(getRes.data.result.direct.approvalEmails), 'Should have approvalEmails array in direct object');
+      assert.strictEqual(getRes.data.result.direct.approvalEmails.length, 2, 'Should have 2 approval emails');
+      
+      await request('DELETE', `/deals/${data.result.dealId}`);
+    });
+  });
+
+  describe('13. PROGRAMMATIC Mode Targeting Rejection', () => {
+    const progDealId = { value: null };
+
+    it('should create PROGRAMMATIC deal for rejection tests', async () => {
+      const { status, data } = await request('POST', '/deals', {
+        name: 'Programmatic Targeting Rejection Deal',
+        externalId: `e2e-prog-reject-${Date.now()}`,
+        source: 'e2e-test',
+        mode: 'PROGRAMMATIC',
+        dealType: 'PRIVATE_AUCTION',
+        currency: 'USD',
+        seller: { id: 'seller-001', name: 'Test Seller' },
+        programmatic: { buyers: [{ id: 'buyer-001', name: 'DSP Buyer', seatId: 'SEAT-001' }] }
+      });
+      assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+      progDealId.value = data.result.dealId;
+    });
+
+    it('should create PROGRAMMATIC line item WITHOUT targeting (baseline)', async () => {
+      if (!progDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const { status, data } = await request('POST', `/deals/${progDealId.value}/line-items`, {
+        externalId: `e2e-li-prog-base-${Date.now()}`,
+        name: 'Programmatic Line Item Baseline',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        programmatic: { costType: 'CPM', bidFloor: 10.00 }
+      });
+      assert.strictEqual(status, 201, `Baseline PROGRAMMATIC creation failed: ${JSON.stringify(data)}`);
+    });
+
+    it('should accept targeting for PROGRAMMATIC line item (filters inventories)', async () => {
+      if (!progDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const { status, data } = await request('POST', `/deals/${progDealId.value}/line-items`, {
+        externalId: `e2e-li-prog-with-targeting-${Date.now()}`,
+        name: 'Programmatic Line Item with Targeting',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        programmatic: { costType: 'CPM', bidFloor: 10.00 },
+        targeting: { 
+          demographics: { ageGroups: ['25-34'], genders: ['male', 'female'] },
+          venueTypes: ['transit.train_stations', 'retail.shopping_mall']
+        },
+        metadata: { version: '1.0', inventoryFilteredBy: ['demographics', 'venueTypes'] }
+      });
+      assert.strictEqual(status, 201, `Should accept targeting for PROGRAMMATIC: ${JSON.stringify(data)}`);
+      
+      const getRes = await request('GET', `/deals/${progDealId.value}/line-items/${data.result.externalId}`);
+      const li = getRes.data.result;
+      assert.ok(li.targeting, 'PROGRAMMATIC line item should have targeting stored');
+      assert.ok(li.targeting.demographics, 'Should have demographics');
+      assert.ok(li.targeting.venueTypes, 'Should have venueTypes');
+    });
+
+    it('should reject deliveryTargeting for PROGRAMMATIC line item (DIRECT-only)', async () => {
+      if (!progDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const { status, data } = await request('POST', `/deals/${progDealId.value}/line-items`, {
+        externalId: `e2e-li-prog-delivery-targeting-${Date.now()}`,
+        name: 'Programmatic Line Item with DeliveryTargeting Attempt',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        programmatic: { costType: 'CPM', bidFloor: 10.00 },
+        deliveryTargeting: { signals: { weather: { conditions: ['sunny'] } } }
+      });
+      assert.strictEqual(status, 400, `Should reject deliveryTargeting for PROGRAMMATIC: ${JSON.stringify(data)}`);
+      assert.ok(data.message && data.message.includes('deliveryTargeting'), 'Error should mention deliveryTargeting');
+    });
+
+    it('should accept PROGRAMMATIC line item with geofencing (polygon + locations)', async () => {
+      if (!progDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const { status, data } = await request('POST', `/deals/${progDealId.value}/line-items`, {
+        externalId: `e2e-li-prog-geofencing-${Date.now()}`,
+        name: 'Programmatic Line Item with Geofencing',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        programmatic: { costType: 'CPM', bidFloor: 8.00 },
+        targeting: {
+          geofencing: {
+            geometrics: [
+              { type: 'Polygon', coordinates: [[[101.68, 3.13], [101.72, 3.13], [101.72, 3.17], [101.68, 3.17], [101.68, 3.13]]], included: true }
+            ],
+            locations: [
+              { name: 'KL Sentral', lat: 3.1336, lng: 101.6865, radius: 1000, included: true }
+            ]
+          }
+        }
+      });
+      assert.strictEqual(status, 201, `Should accept PROGRAMMATIC with geofencing: ${JSON.stringify(data)}`);
+      
+      const getRes = await request('GET', `/deals/${progDealId.value}/line-items/${data.result.externalId}`);
+      const li = getRes.data.result;
+      assert.ok(li.targeting && li.targeting.geofencing, 'Should have geofencing stored');
+      assert.ok(li.targeting.geofencing.geometrics, 'Should have geometrics');
+      assert.ok(li.targeting.geofencing.locations, 'Should have locations');
+    });
+
+    it('should update PROGRAMMATIC line item targeting and verify persistence', async () => {
+      if (!progDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const createRes = await request('POST', `/deals/${progDealId.value}/line-items`, {
+        externalId: `e2e-li-prog-update-targeting-${Date.now()}`,
+        name: 'Programmatic Line Item for Targeting Update',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        programmatic: { costType: 'CPM', bidFloor: 5.00 },
+        targeting: { demographics: { ageGroups: ['18-24'] } }
+      });
+      assert.strictEqual(createRes.status, 201);
+      
+      const updateRes = await request('PUT', `/deals/${progDealId.value}/line-items/${createRes.data.result.externalId}`, {
+        targeting: {
+          demographics: { ageGroups: ['25-34', '35-44'], genders: ['male'] },
+          venueTypes: ['retail.shopping_mall', 'transit.bus_stops']
+        },
+        metadata: { version: '2.0', inventoryFilteredBy: ['demographics', 'venueTypes'] }
+      });
+      assert.strictEqual(updateRes.status, 200, `Should update PROGRAMMATIC targeting: ${JSON.stringify(updateRes.data)}`);
+      
+      // Verify via GET single item
+      const getRes = await request('GET', `/deals/${progDealId.value}/line-items/${createRes.data.result.externalId}`);
+      const li = getRes.data.result;
+      assert.deepStrictEqual(li.targeting.demographics.ageGroups, ['25-34', '35-44'], 'Updated ageGroups');
+      assert.ok(li.targeting.venueTypes.includes('retail.shopping_mall'), 'Updated venueTypes');
+      assert.strictEqual(li.metadata.version, '2.0', 'Updated metadata version');
+      
+      // Verify via GET list (targeting persists in list response)
+      const listRes = await request('GET', `/deals/${progDealId.value}/line-items`);
+      const liFromList = listRes.data.result.data.find(item => item.externalId === createRes.data.result.externalId);
+      assert.ok(liFromList.targeting, 'Targeting should appear in list response');
+      assert.ok(liFromList.targeting.demographics, 'Demographics should appear in list response');
+    });
+
+    it('should reject PROGRAMMATIC line item update with deliveryTargeting (verify error payload)', async () => {
+      if (!progDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const createRes = await request('POST', `/deals/${progDealId.value}/line-items`, {
+        externalId: `e2e-li-prog-reject-update-${Date.now()}`,
+        name: 'Programmatic Line Item for Update Rejection',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        programmatic: { costType: 'CPM', bidFloor: 5.00 }
+      });
+      assert.strictEqual(createRes.status, 201);
+      
+      const updateRes = await request('PUT', `/deals/${progDealId.value}/line-items/${createRes.data.result.externalId}`, {
+        deliveryTargeting: { signals: { weather: { conditions: ['rainy'] } } }
+      });
+      assert.strictEqual(updateRes.status, 400, 'Should reject deliveryTargeting update for PROGRAMMATIC');
+      assert.strictEqual(updateRes.data.code, 'VALIDATION_ERROR', 'Error code should be VALIDATION_ERROR');
+      assert.ok(updateRes.data.message && updateRes.data.message.includes('deliveryTargeting'), 'Error message should mention deliveryTargeting');
+      assert.ok(updateRes.data.message.includes('DIRECT') || updateRes.data.message.includes('PROGRAMMATIC'), 'Error message should mention mode restriction');
+    });
+
+    it('should archive programmatic rejection test deal', async () => {
+      if (!progDealId.value) { assert.ok(true, 'Skipping'); return; }
+      const { status } = await request('DELETE', `/deals/${progDealId.value}`);
+      assert.ok([200, 404].includes(status));
+    });
+  });
+
+  describe('13. Edge Cases - Validation & Error Handling', () => {
+    const edgeDealId = { value: null };
+
+    it('should reject DIRECT deal missing required fields', async () => {
+      const { status } = await request('POST', '/deals', {
+        name: 'Invalid Direct Deal',
+        externalId: `e2e-invalid-direct-${Date.now()}`,
+        source: 'e2e-test',
+        mode: 'DIRECT',
+        dealType: 'DIRECT',
+        currency: 'MYR',
+        seller: { id: 'seller-001', name: 'Test Seller' }
+      });
+      assert.strictEqual(status, 400, 'Should reject DIRECT deal missing required fields');
+    });
+
+    it('should reject invalid dealType for PROGRAMMATIC mode', async () => {
+      const { status } = await request('POST', '/deals', {
+        name: 'Invalid DealType',
+        externalId: `e2e-invalid-type-${Date.now()}`,
+        source: 'e2e-test',
+        mode: 'PROGRAMMATIC',
+        dealType: 'DIRECT',
+        currency: 'USD',
+        seller: { id: 'seller-001', name: 'Test Seller' }
+      });
+      assert.strictEqual(status, 400, 'Should reject invalid dealType for mode');
+    });
+
+    it('should create DIRECT deal for inventory planning tests', async () => {
+      const { status, data } = await request('POST', '/deals', {
+        name: 'Edge Test DIRECT Deal',
+        externalId: `e2e-edge-direct-${Date.now()}`,
+        source: 'e2e-test',
+        mode: 'DIRECT',
+        dealType: 'DIRECT',
+        currency: 'MYR',
+        seller: { id: 'seller-001', name: 'Test Seller' },
+        direct: {
+          brand: 'Edge Test Brand',
+          clientType: 'DIRECT_ADVERTISER',
+          approvalEmails: ['test@example.com'],
+          marketSelection: { country: 'MY', currency: 'MYR' },
+          budgetSetup: { currency: 'MYR', budgetAmount: 100000 },
+          campaignGoal: { type: 'IMPRESSIONS', targetValue: 500000 }
+        }
+      });
+      assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+      edgeDealId.value = data.result.dealId;
+    });
+
+    it('should create DIRECT line item with inventory-level planning', async () => {
+      if (!edgeDealId.value) {
+        assert.ok(true, 'Skipping - deal creation failed');
+        return;
+      }
+      const ts = Date.now();
+      const { status, data } = await request('POST', `/deals/${edgeDealId.value}/line-items`, {
+        externalId: `e2e-li-inv-planning-${ts}`,
+        name: 'Line Item with Inventory Planning',
+        creativeType: 'DISPLAY',
+        timezoneId: 'Asia/Kuala_Lumpur',
+        startDate: '2025-01-15',
+        endDate: '2025-02-28',
+        resolutions: ['1920x1080'],
+        creativeSource: 'ADVERTISER',
+        inventories: [
+          {
+            id: `inv-edge-plan-1-${ts}`,
+            name: 'Inventory with Planning 1',
+            size: '1920x1080',
+            publisherId: 'pub-edge-001',
+            publisherName: 'Edge Publisher',
+            venueType: 'SHOPPING_MALL',
+            planning: {
+              capacity: { campaignDays: 45, available: { slots: 178200, playTimeSec: 2673000, maxImpressions: 21000000 } },
+              allocation: { slots: 3960, playTimeSec: 59400, sov: 0.0222, sot: 0.0222 },
+              estimates: { impressions: 933750, reach: 213750, frequency: 4.37 },
+              pricing: { cpm: 2677.50, estimatedCost: 2500000 }
+            }
+          },
+          {
+            id: `inv-edge-plan-2-${ts}`,
+            name: 'Inventory with Planning 2',
+            size: '1920x1080',
+            publisherId: 'pub-edge-001',
+            publisherName: 'Edge Publisher',
+            venueType: 'TRANSIT',
+            planning: {
+              capacity: { campaignDays: 45, available: { slots: 89100, playTimeSec: 1336500, maxImpressions: 10500000 } },
+              allocation: { slots: 1980, playTimeSec: 29700, sov: 0.0222, sot: 0.0222 },
+              estimates: { impressions: 466875, reach: 106875, frequency: 4.37 },
+              pricing: { cpm: 2677.50, estimatedCost: 1250000 }
+            }
+          }
+        ]
+      });
+      assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+    });
+
+    it('should retrieve line items and verify inventories', async () => {
+      if (!edgeDealId.value) {
+        assert.ok(true, 'Skipping - deal creation failed');
+        return;
+      }
+      const { status, data } = await request('GET', `/deals/${edgeDealId.value}/line-items`);
+      assert.strictEqual(status, 200, `Failed: ${JSON.stringify(data)}`);
+      assert.ok(data.result.data.length >= 1, 'Should have at least 1 line item');
+      const lineItem = data.result.data[0];
+      const invRes = await request('GET', `/deals/${edgeDealId.value}/line-items/${lineItem.id}/inventories`);
+      assert.strictEqual(invRes.status, 200, `Failed: ${JSON.stringify(invRes.data)}`);
+    });
+
+    it('should handle empty schedule array', async () => {
+      if (!edgeDealId.value) {
+        assert.ok(true, 'Skipping - deal creation failed');
+        return;
+      }
+      const { status, data } = await request('POST', `/deals/${edgeDealId.value}/line-items`, {
+        externalId: `e2e-li-empty-schedule-${Date.now()}`,
+        name: 'Line Item with Empty Schedule',
+        creativeType: 'DISPLAY',
+        timezoneId: 'Asia/Kuala_Lumpur',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        schedule: []
+      });
+      assert.strictEqual(status, 201, `Should accept empty schedule array: ${JSON.stringify(data)}`);
+    });
+
+    it('should accept schedule with all rule types', async () => {
+      if (!edgeDealId.value) {
+        assert.ok(true, 'Skipping - deal creation failed');
+        return;
+      }
+      const { status, data } = await request('POST', `/deals/${edgeDealId.value}/line-items`, {
+        externalId: `e2e-li-full-schedule-${Date.now()}`,
+        name: 'Line Item with Full Schedule',
+        creativeType: 'DISPLAY',
+        timezoneId: 'Asia/Kuala_Lumpur',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        schedule: [
+          { type: 'DEFAULT', hours: [{ start: 0, end: 23 }] },
+          { type: 'WEEKDAY', priority: 50, daysOfWeek: [1,2,3,4,5], validity: { startDate: '2025-01-01', endDate: '2025-12-31' }, hours: [{ start: 8, end: 20 }] },
+          { type: 'WEEKEND', priority: 50, daysOfWeek: [6,7], hours: [{ start: 10, end: 18 }] },
+          { type: 'CUSTOM', date: '2025-12-25', hours: [{ start: 12, end: 16 }] }
+        ]
+      });
+      assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+    });
+
+    it('should reject line item with invalid schedule type', async () => {
+      if (!edgeDealId.value) {
+        assert.ok(true, 'Skipping - deal creation failed');
+        return;
+      }
+      const { status } = await request('POST', `/deals/${edgeDealId.value}/line-items`, {
+        externalId: `e2e-li-invalid-schedule-${Date.now()}`,
+        name: 'Line Item with Invalid Schedule',
+        creativeType: 'DISPLAY',
+        timezoneId: 'Asia/Kuala_Lumpur',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        schedule: [
+          { type: 'INVALID_TYPE', hours: [{ start: 0, end: 23 }] }
+        ]
+      });
+      assert.strictEqual(status, 400, 'Should reject invalid schedule type');
+    });
+
+    it('should reject duplicate externalId with detailed error message', async () => {
+      if (!edgeDealId.value) {
+        assert.ok(true, 'Skipping - deal creation failed');
+        return;
+      }
+      const externalId = `e2e-li-dup-${Date.now()}`;
+      await request('POST', `/deals/${edgeDealId.value}/line-items`, {
+        externalId,
+        name: 'First Line Item',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080']
+      });
+      const { status, data } = await request('POST', `/deals/${edgeDealId.value}/line-items`, {
+        externalId,
+        name: 'Duplicate Line Item',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080']
+      });
+      assert.strictEqual(status, 409, 'Should reject duplicate externalId');
+      assert.strictEqual(data.code, 'CONFLICT', 'Error code should be CONFLICT');
+      assert.ok(data.message.includes('Duplicate'), 'Error message should mention duplicate');
+      assert.ok(Array.isArray(data.details), 'Should include error details array');
+      assert.ok(data.details.some(d => d.field === 'external_id'), 'Details should include external_id field');
+    });
+
+    it('should handle GET non-existent deal', async () => {
+      const { status } = await request('GET', '/deals/non-existent-deal-id');
+      assert.strictEqual(status, 404);
+    });
+
+    it('should handle GET non-existent line item', async () => {
+      if (!edgeDealId.value) {
+        assert.ok(true, 'Skipping - deal creation failed');
+        return;
+      }
+      const { status } = await request('GET', `/deals/${edgeDealId.value}/line-items/non-existent-id`);
+      assert.strictEqual(status, 404);
+    });
+
+    it('should archive edge test deal', async () => {
+      if (!edgeDealId.value) {
+        assert.ok(true, 'Skipping - no deal to archive');
+        return;
+      }
+      const { status } = await request('DELETE', `/deals/${edgeDealId.value}`);
+      assert.ok([200, 404].includes(status));
+    });
+  });
+
+  describe('14. Dual ID Resolution (UUID or dealId)', () => {
+    const dualIdDeal = { value: null };
+    const dualIdLineItem = { value: null };
+    const dualIdCreative = { value: null };
+
+    it('should create a deal for dual ID testing', async () => {
+      const { status, data } = await request('POST', '/deals', {
+        name: 'Dual ID Test Deal',
+        externalId: `e2e-dual-id-${Date.now()}`,
+        source: 'e2e-test',
+        mode: 'PROGRAMMATIC',
+        dealType: 'GUARANTEED',
+        currency: 'USD',
+        seller: { id: 'seller-dual', name: 'Dual ID Seller' },
+        programmatic: {
+          buyers: [{ id: 'buyer-dual', name: 'Dual ID Buyer' }],
+          transactionType: 'SPOT',
+          costType: 'CPM'
+        }
+      });
+      assert.strictEqual(status, 201);
+      dualIdDeal.value = data.result;
+    });
+
+    it('should GET deal by dealId', async () => {
+      const { status, data } = await request('GET', `/deals/${dualIdDeal.value.dealId}`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.dealId, dualIdDeal.value.dealId);
+    });
+
+    it('should GET deal by UUID (id field)', async () => {
+      const { status, data } = await request('GET', `/deals/${dualIdDeal.value.id}`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.id, dualIdDeal.value.id);
+    });
+
+    it('should PUT deal by UUID', async () => {
+      const { status, data } = await request('PUT', `/deals/${dualIdDeal.value.id}`, { status: 'APPROVED' });
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.status, 'APPROVED');
+    });
+
+    it('should create line item for dual ID testing', async () => {
+      const { status, data } = await request('POST', `/deals/${dualIdDeal.value.id}/line-items`, {
+        externalId: `e2e-dual-li-${Date.now()}`,
+        name: 'Dual ID Line Item',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        thresholdCountPerDay: 50,
+        programmatic: { costType: 'CPM', bidFloor: 5.00 }
+      });
+      assert.strictEqual(status, 201);
+      dualIdLineItem.value = data.result;
+    });
+
+    it('should GET line items using deal UUID', async () => {
+      const { status, data } = await request('GET', `/deals/${dualIdDeal.value.id}/line-items`);
+      assert.strictEqual(status, 200);
+      assert.ok(data.result.data.length >= 1);
+    });
+
+    it('should GET line item using deal UUID and line item id', async () => {
+      const { status, data } = await request('GET', `/deals/${dualIdDeal.value.id}/line-items/${dualIdLineItem.value.id}`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.id, dualIdLineItem.value.id);
+    });
+
+    it('should GET line item using deal UUID and externalId', async () => {
+      const { status, data } = await request('GET', `/deals/${dualIdDeal.value.id}/line-items/${dualIdLineItem.value.externalId}`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.externalId, dualIdLineItem.value.externalId);
+    });
+
+    it('should PUT line item using deal UUID', async () => {
+      const { status, data } = await request('PUT', `/deals/${dualIdDeal.value.id}/line-items/${dualIdLineItem.value.externalId}`, {
+        name: 'Updated via UUID'
+      });
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.name, 'Updated via UUID');
+    });
+
+    it('should POST creative using deal UUID', async () => {
+      const { status, data } = await request('POST', `/deals/${dualIdDeal.value.id}/line-items/${dualIdLineItem.value.externalId}/creatives`, {
+        creativeId: `e2e-dual-creative-${Date.now()}`,
+        creativeUri: 'https://cdn.example.com/dual-test.jpg',
+        creativeType: 'DISPLAY',
+        resolution: '1920x1080'
+      });
+      assert.strictEqual(status, 201);
+      dualIdCreative.value = data.result;
+    });
+
+    it('should GET creatives using deal UUID', async () => {
+      const { status, data } = await request('GET', `/deals/${dualIdDeal.value.id}/creatives`);
+      assert.strictEqual(status, 200);
+      assert.ok(data.result.data.length >= 1);
+    });
+
+    it('should GET creatives using deal UUID and line item externalId', async () => {
+      const { status, data } = await request('GET', `/deals/${dualIdDeal.value.id}/line-items/${dualIdLineItem.value.externalId}/creatives`);
+      assert.strictEqual(status, 200);
+      assert.ok(data.result.data.length >= 1);
+    });
+
+    it('should GET single creative using deal UUID', async () => {
+      const { status, data } = await request('GET', `/deals/${dualIdDeal.value.id}/line-items/${dualIdLineItem.value.externalId}/creatives/${dualIdCreative.value.creativeId}`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.creativeId, dualIdCreative.value.creativeId);
+    });
+
+    it('should GET creative by creative UUID using deal UUID', async () => {
+      const { status, data } = await request('GET', `/deals/${dualIdDeal.value.id}/line-items/${dualIdLineItem.value.externalId}/creatives/${dualIdCreative.value.id}`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.id, dualIdCreative.value.id);
+    });
+
+    it('should POST approve creative using deal UUID', async () => {
+      const { status, data } = await request('POST', `/deals/${dualIdDeal.value.id}/line-items/${dualIdLineItem.value.externalId}/creatives/${dualIdCreative.value.creativeId}`, {
+        decision: 'APPROVED',
+        reviewerId: 'reviewer-dual',
+        reviewerName: 'Dual ID Reviewer'
+      });
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.status, 'APPROVED');
+    });
+
+    it('should create another creative for reject test', async () => {
+      const { status, data } = await request('POST', `/deals/${dualIdDeal.value.id}/line-items/${dualIdLineItem.value.externalId}/creatives`, {
+        creativeId: `e2e-dual-creative-reject-${Date.now()}`,
+        creativeUri: 'https://cdn.example.com/dual-reject.jpg',
+        creativeType: 'DISPLAY',
+        resolution: '1920x1080'
+      });
+      assert.strictEqual(status, 201);
+      dualIdCreative.rejectTest = data.result;
+    });
+
+    it('should POST reject creative using deal UUID', async () => {
+      const { status, data } = await request('POST', `/deals/${dualIdDeal.value.id}/line-items/${dualIdLineItem.value.externalId}/creatives/${dualIdCreative.rejectTest.creativeId}`, {
+        decision: 'REJECTED',
+        reviewerId: 'reviewer-dual',
+        reviewerName: 'Dual ID Reviewer',
+        reason: 'Testing reject via UUID'
+      });
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.status, 'REJECTED');
+    });
+
+    it('should create creative for delete test', async () => {
+      const { status, data } = await request('POST', `/deals/${dualIdDeal.value.id}/line-items/${dualIdLineItem.value.externalId}/creatives`, {
+        creativeId: `e2e-dual-creative-delete-${Date.now()}`,
+        creativeUri: 'https://cdn.example.com/dual-delete.jpg',
+        creativeType: 'DISPLAY',
+        resolution: '1920x1080'
+      });
+      assert.strictEqual(status, 201);
+      dualIdCreative.deleteTest = data.result;
+    });
+
+    it('should DELETE creative using deal UUID', async () => {
+      const { status, data } = await request('DELETE', `/deals/${dualIdDeal.value.id}/line-items/${dualIdLineItem.value.externalId}/creatives/${dualIdCreative.deleteTest.creativeId}`);
+      assert.strictEqual(status, 200);
+      assert.ok(data.result.message.includes('deleted'));
+    });
+
+    it('should DELETE creative by creative UUID using deal UUID', async () => {
+      const createRes = await request('POST', `/deals/${dualIdDeal.value.id}/line-items/${dualIdLineItem.value.externalId}/creatives`, {
+        creativeId: `e2e-dual-creative-delete2-${Date.now()}`,
+        creativeUri: 'https://cdn.example.com/dual-delete2.jpg',
+        creativeType: 'DISPLAY',
+        resolution: '1920x1080'
+      });
+      assert.strictEqual(createRes.status, 201);
+      
+      const { status, data } = await request('DELETE', `/deals/${dualIdDeal.value.id}/line-items/${dualIdLineItem.value.externalId}/creatives/${createRes.data.result.id}`);
+      assert.strictEqual(status, 200);
+    });
+
+    it('should archive deal using UUID', async () => {
+      const { status } = await request('DELETE', `/deals/${dualIdDeal.value.id}`);
+      assert.strictEqual(status, 200);
+    });
+
+    it('should verify archived deal by UUID', async () => {
+      const { status, data } = await request('GET', `/deals/${dualIdDeal.value.id}`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.status, 'ARCHIVED');
+    });
+  });
+
+  describe('15. Minified Inventory Endpoints', () => {
+    let minifiedTestDeal = {};
+    let minifiedTestLineItem = {};
+
+    it('should create a deal with line items and inventories for minified test', async () => {
+      const dealPayload = {
+        name: 'Minified Inventory Test Deal',
+        externalId: `e2e-minified-${Date.now()}`,
+        source: 'e2e-test',
+        mode: 'PROGRAMMATIC',
+        dealType: 'PRIVATE_AUCTION',
+        currency: 'USD'
+      };
+      const { status, data } = await request('POST', '/deals', dealPayload);
+      assert.strictEqual(status, 201);
+      minifiedTestDeal = data.result;
+    });
+
+    it('should create a line item with inventories', async () => {
+      const lineItemPayload = {
+        externalId: `e2e-li-minified-${Date.now()}`,
+        name: 'Minified Test Line Item',
+        creativeType: 'DISPLAY',
+        timezoneId: 'America/New_York',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        programmatic: {
+          costType: 'CPM',
+          bidFloor: 5.00
+        },
+        inventories: [
+          { id: 'inv-minified-001', deviceId: 'device-alpha-001', name: 'Screen Alpha', size: '1920x1080', publisherId: 'pub-001', publisherName: 'Publisher One', metadata: { externalRefIds: [{ source: 'LMX', externalRefId: 'lmx-alpha-001' }] } },
+          { id: 'inv-minified-002', deviceId: 'device-beta-001', name: 'Screen Beta', size: '1280x720', publisherId: 'pub-002', publisherName: 'Publisher Two' },
+          { id: 'inv-minified-003', name: 'Screen Gamma', size: '1920x1080', publisherId: 'pub-001', publisherName: 'Publisher One' }
+        ]
+      };
+      const { status, data } = await request('POST', `/deals/${minifiedTestDeal.dealId}/line-items`, lineItemPayload);
+      assert.strictEqual(status, 201);
+      minifiedTestLineItem = data.result;
+    });
+
+    it('should GET minified inventories for deal', async () => {
+      const { status, data } = await request('GET', `/deals/${minifiedTestDeal.dealId}/inventories/minified`);
+      assert.strictEqual(status, 200);
+      assert.ok(Array.isArray(data.result.data));
+      assert.strictEqual(data.result.total, 3);
+      
+      const inv = data.result.data[0];
+      assert.ok(inv.id);
+      assert.ok(inv.name);
+      assert.ok(inv.publisher);
+      assert.ok(inv.publisher.id);
+      assert.ok(inv.publisher.name);
+      assert.ok(inv.resolution);
+      
+      assert.strictEqual(Object.keys(inv).length, 4);
+    });
+
+    it('should GET minified inventories for deal using UUID', async () => {
+      const { status, data } = await request('GET', `/deals/${minifiedTestDeal.id}/inventories/minified`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.total, 3);
+    });
+
+    it('should GET minified inventories for line item', async () => {
+      const { status, data } = await request('GET', `/deals/${minifiedTestDeal.dealId}/line-items/${minifiedTestLineItem.externalId}/inventories/minified`);
+      assert.strictEqual(status, 200);
+      assert.ok(Array.isArray(data.result.data));
+      assert.strictEqual(data.result.total, 3);
+      
+      const inv = data.result.data[0];
+      assert.ok(inv.id);
+      assert.ok(inv.name);
+      assert.ok(inv.publisher);
+      assert.ok(inv.resolution);
+    });
+
+    it('should GET minified inventories for line item using deal UUID', async () => {
+      const { status, data } = await request('GET', `/deals/${minifiedTestDeal.id}/line-items/${minifiedTestLineItem.externalId}/inventories/minified`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.total, 3);
+    });
+
+    it('should return 404 for minified inventories with invalid deal', async () => {
+      const { status } = await request('GET', '/deals/INVALID-DEAL/inventories/minified');
+      assert.strictEqual(status, 404);
+    });
+
+    it('should return 404 for minified inventories with invalid line item', async () => {
+      const { status } = await request('GET', `/deals/${minifiedTestDeal.dealId}/line-items/INVALID-LI/inventories/minified`);
+      assert.strictEqual(status, 404);
+    });
+
+    it('should cleanup - archive minified test deal', async () => {
+      const { status } = await request('DELETE', `/deals/${minifiedTestDeal.dealId}`);
+      assert.strictEqual(status, 200);
+    });
+  });
+
+  describe('16. Inventory Replacement (PUT)', () => {
+    let invTestDeal;
+    let invTestLineItem;
+
+    it('should create test deal for inventory replacement', async () => {
+      const { status, data } = await request('POST', '/deals', {
+        name: 'Inventory Replacement Test Deal',
+        externalId: `inv-replace-test-${Date.now()}`,
+        source: 'e2e-test',
+        mode: 'PROGRAMMATIC',
+        dealType: 'PREFERRED_DEAL',
+        currency: 'USD',
+        seller: { id: 'seller-inv-test', name: 'Inventory Test Seller' },
+        programmatic: {
+          buyers: [{ id: 'buyer-inv-test', name: 'Test Buyer' }],
+          transactionType: 'SPOT',
+          costType: 'CPM'
+        }
+      });
+      assert.strictEqual(status, 201);
+      invTestDeal = data.result;
+    });
+
+    it('should create line item with initial inventories', async () => {
+      const { status, data } = await request('POST', `/deals/${invTestDeal.dealId}/line-items`, {
+        externalId: `li-inv-test-${Date.now()}`,
+        name: 'Inventory Replacement Test Line Item',
+        creativeType: 'DISPLAY',
+        timezoneId: 'UTC',
+        startDate: '2025-01-01',
+        endDate: '2025-12-31',
+        resolutions: ['1920x1080'],
+        programmatic: { costType: 'CPM', bidFloor: 5.00 },
+        inventories: [
+          { id: 'inv-original-001', name: 'Original Screen 1', size: '1920x1080' },
+          { id: 'inv-original-002', name: 'Original Screen 2', size: '1920x1080' }
+        ]
+      });
+      assert.strictEqual(status, 201);
+      invTestLineItem = data.result;
+    });
+
+    it('should verify original inventories exist', async () => {
+      const { status, data } = await request('GET', `/deals/${invTestDeal.dealId}/line-items/${invTestLineItem.externalId}/inventories`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.pagination.total, 2);
+    });
+
+    it('should replace inventories with new list', async () => {
+      const { status, data } = await request('PUT', `/deals/${invTestDeal.dealId}/line-items/${invTestLineItem.externalId}/inventories`, {
+        inventories: [
+          { id: 'inv-new-001', name: 'New Screen A', size: '1920x1080', deviceId: 'DEVICE-A' },
+          { id: 'inv-new-002', name: 'New Screen B', size: '3840x2160', deviceId: 'DEVICE-B' },
+          { id: 'inv-new-003', name: 'New Screen C', size: '1920x1080', publisher: { id: 'pub-new', name: 'New Publisher' } }
+        ]
+      });
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.inventoriesCount, 3);
+      assert.strictEqual(data.result.message, 'Inventories replaced successfully');
+    });
+
+    it('should verify new inventories replaced old ones', async () => {
+      const { status, data } = await request('GET', `/deals/${invTestDeal.dealId}/line-items/${invTestLineItem.externalId}/inventories`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.pagination.total, 3);
+      
+      const invIds = data.result.data.map(inv => inv.id);
+      assert.ok(invIds.includes('inv-new-001'));
+      assert.ok(invIds.includes('inv-new-002'));
+      assert.ok(invIds.includes('inv-new-003'));
+      assert.ok(!invIds.includes('inv-original-001'));
+      assert.ok(!invIds.includes('inv-original-002'));
+    });
+
+    it('should replace with empty list to clear inventories', async () => {
+      const { status, data } = await request('PUT', `/deals/${invTestDeal.dealId}/line-items/${invTestLineItem.externalId}/inventories`, {
+        inventories: []
+      });
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.inventoriesCount, 0);
+    });
+
+    it('should verify all inventories cleared', async () => {
+      const { status, data } = await request('GET', `/deals/${invTestDeal.dealId}/line-items/${invTestLineItem.externalId}/inventories`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.pagination.total, 0);
+    });
+
+    it('should reject PUT inventories with missing required id', async () => {
+      const { status, data } = await request('PUT', `/deals/${invTestDeal.dealId}/line-items/${invTestLineItem.externalId}/inventories`, {
+        inventories: [
+          { name: 'Screen Without ID', size: '1920x1080' }
+        ]
+      });
+      assert.strictEqual(status, 400);
+      assert.strictEqual(data.code, 'VALIDATION_ERROR');
+    });
+
+    it('should replace with inventories including metadata.externalRefIds', async () => {
+      const { status, data } = await request('PUT', `/deals/${invTestDeal.dealId}/line-items/${invTestLineItem.externalId}/inventories`, {
+        inventories: [
+          { 
+            id: 'inv-ext-001', 
+            name: 'Screen with External Refs',
+            size: '1920x1080',
+            metadata: {
+              externalRefIds: [
+                { source: 'LMX', externalRefId: 'lmx-12345' },
+                { source: 'BROADSIGN', externalRefId: 'bs-67890' }
+              ]
+            }
+          }
+        ]
+      });
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.inventoriesCount, 1);
+    });
+
+    it('should verify externalRefIds persisted', async () => {
+      const { status, data } = await request('GET', `/deals/${invTestDeal.dealId}/line-items/${invTestLineItem.externalId}/inventories`);
+      assert.strictEqual(status, 200);
+      const inv = data.result.data[0];
+      assert.ok(inv.metadata?.externalRefIds);
+      assert.strictEqual(inv.metadata.externalRefIds.length, 2);
+      assert.strictEqual(inv.metadata.externalRefIds[0].source, 'LMX');
+    });
+
+    it('should return 404 for invalid deal', async () => {
+      const { status } = await request('PUT', '/deals/INVALID-DEAL/line-items/li-test/inventories', {
+        inventories: []
+      });
+      assert.strictEqual(status, 404);
+    });
+
+    it('should return 404 for invalid line item', async () => {
+      const { status } = await request('PUT', `/deals/${invTestDeal.dealId}/line-items/INVALID-LI/inventories`, {
+        inventories: []
+      });
+      assert.strictEqual(status, 404);
+    });
+
+    it('should cleanup - archive inventory test deal', async () => {
+      const { status } = await request('DELETE', `/deals/${invTestDeal.dealId}`);
+      assert.strictEqual(status, 200);
+    });
+  });
+
+  describe('17. Auto-IO Creation via Import with DIRECT_PUBLISHER_SPLIT', () => {
+    it('should auto-create insertion orders when importing DIRECT_PUBLISHER_SPLIT payload', async () => {
+      const timestamp = Date.now();
+      const { status, data } = await request('POST', '/deals/import', {
+        payloadType: 'DIRECT_PUBLISHER_SPLIT',
+        externalPayload: {
+          campaign: {
+            externalId: `import-auto-io-${timestamp}`,
+            source: 'e2e-test',
+            name: 'Auto IO Import Test',
+            status: 'DRAFT',
+            currency: 'USD',
+            brand: 'TestBrand',
+            clientType: 'AGENCY',
+            marketSelection: { country: 'US', currency: 'USD' },
+            budgetSetup: { currency: 'USD', budgetAmount: 50000, budgetType: 'TOTAL' },
+            campaignGoal: { type: 'IMPRESSIONS', targetValue: 500000 },
+            startDate: '2025-02-01',
+            endDate: '2025-04-30',
+            timezoneId: 'America/Chicago',
+            creativeType: 'DISPLAY'
+          },
+          inventories: [
+            { id: `inv-1-${timestamp}`, name: 'Screen 1', size: '1920x1080', publisher: { id: 'pub-a', name: 'Publisher A' } },
+            { id: `inv-2-${timestamp}`, name: 'Screen 2', size: '1920x1080', publisher: { id: 'pub-a', name: 'Publisher A' } },
+            { id: `inv-3-${timestamp}`, name: 'Screen 3', size: '1920x1080', publisher: { id: 'pub-b', name: 'Publisher B' } }
+          ]
+        }
+      });
+      
+      assert.strictEqual(status, 201, `Import should succeed: ${JSON.stringify(data)}`);
+      assert.strictEqual(data.result.summary.payloadType, 'DIRECT_PUBLISHER_SPLIT');
+      assert.strictEqual(data.result.summary.insertionOrdersCreated, 2);
+      assert.strictEqual(data.result.summary.lineItemsProcessed, 2);
+      
+      const dealId = data.result.deal.dealId;
+      const { status: getStatus, data: getData } = await request('GET', `/deals/${dealId}?embed=insertionOrders`);
+      assert.strictEqual(getStatus, 200);
+      assert.ok(getData.result.insertionOrders);
+      assert.strictEqual(getData.result.insertionOrders.length, 2);
+      
+      await request('DELETE', `/deals/${dealId}`);
+    });
+
+    it('should create individual line items for scheduled inventories and group the rest', async () => {
+      const timestamp = Date.now();
+      const { status, data } = await request('POST', '/deals/import', {
+        payloadType: 'DIRECT_PUBLISHER_SPLIT',
+        externalPayload: {
+          campaign: {
+            externalId: `import-schedule-${timestamp}`,
+            source: 'e2e-test',
+            name: 'Scheduled Import Test',
+            status: 'DRAFT',
+            currency: 'USD',
+            brand: 'TestBrand',
+            clientType: 'AGENCY',
+            marketSelection: { country: 'US', currency: 'USD' },
+            budgetSetup: { currency: 'USD', budgetAmount: 100000, budgetType: 'TOTAL' },
+            campaignGoal: { type: 'IMPRESSIONS', targetValue: 1000000 },
+            startDate: '2025-03-01',
+            endDate: '2025-05-31',
+            timezoneId: 'America/New_York',
+            creativeType: 'DISPLAY'
+          },
+          inventories: [
+            // Inventory with schedule -> individual line item
+            { 
+              id: `inv-sched-1-${timestamp}`, 
+              name: 'Premium Screen', 
+              size: '1920x1080', 
+              publisher: { id: 'pub-x', name: 'Publisher X' },
+              schedule: [{ type: 'CUSTOM', date: '2025-03-15', hours: [{ start: 8, end: 18 }] }]
+            },
+            // Inventory with schedule -> individual line item
+            { 
+              id: `inv-sched-2-${timestamp}`, 
+              name: 'Evening Screen', 
+              size: '1920x1080', 
+              publisher: { id: 'pub-x', name: 'Publisher X' },
+              schedule: [{ type: 'CUSTOM', date: '2025-03-16', hours: [{ start: 18, end: 22 }] }]
+            },
+            // Non-scheduled inventories -> grouped by publisher + resolution + duration
+            { id: `inv-grp-1-${timestamp}`, name: 'Standard 1', size: '1920x1080', publisher: { id: 'pub-x', name: 'Publisher X' } },
+            { id: `inv-grp-2-${timestamp}`, name: 'Standard 2', size: '1920x1080', publisher: { id: 'pub-x', name: 'Publisher X' } },
+            { id: `inv-grp-3-${timestamp}`, name: 'Portrait 1', size: '1080x1920', publisher: { id: 'pub-x', name: 'Publisher X' } },
+            { id: `inv-grp-4-${timestamp}`, name: 'Standard 3', size: '1920x1080', publisher: { id: 'pub-y', name: 'Publisher Y' } }
+          ]
+        }
+      });
+      
+      assert.strictEqual(status, 201, `Import should succeed: ${JSON.stringify(data)}`);
+      assert.strictEqual(data.result.summary.payloadType, 'DIRECT_PUBLISHER_SPLIT');
+      // 2 scheduled + 3 groups (pub-x|1920x1080, pub-x|1080x1920, pub-y|1920x1080) = 5 line items
+      assert.strictEqual(data.result.summary.lineItemsProcessed, 5);
+      
+      const dealId = data.result.deal.dealId;
+      const { status: getStatus, data: getData } = await request('GET', `/deals/${dealId}?embed=lineItems`);
+      assert.strictEqual(getStatus, 200);
+      assert.strictEqual(getData.result.lineItems.length, 5);
+      
+      // Verify scheduled line items have 1 inventory each
+      const scheduledLIs = getData.result.lineItems.filter(li => li.name.includes('Premium Screen') || li.name.includes('Evening Screen'));
+      assert.strictEqual(scheduledLIs.length, 2);
+      
+      await request('DELETE', `/deals/${dealId}`);
+    });
+
+    it('should create individual line items for inventories with valid schedules and group those without', async () => {
+      const timestamp = Date.now();
+      const { status, data } = await request('POST', '/deals/import', {
+        payloadType: 'DIRECT_PUBLISHER_SPLIT',
+        externalPayload: {
+          campaign: {
+            externalId: `test-schedule-key-${timestamp}`,
+            source: 'e2e-test',
+            name: 'Schedule Key Test',
+            status: 'DRAFT',
+            currency: 'USD',
+            brand: 'TestBrand',
+            clientType: 'AGENCY',
+            marketSelection: { country: 'US', currency: 'USD' },
+            budgetSetup: { currency: 'USD', budgetAmount: 100000, budgetType: 'TOTAL' },
+            campaignGoal: { type: 'IMPRESSIONS', targetValue: 1000000 },
+            startDate: '2025-03-01',
+            endDate: '2025-05-31',
+            timezoneId: 'America/New_York',
+            creativeType: 'DISPLAY'
+          },
+          inventories: [
+            // Inventory WITH valid schedule -> individual line item
+            { 
+              id: `inv-with-sched-1-${timestamp}`, 
+              name: 'Screen with Schedule', 
+              size: '1920x1080', 
+              publisher: { id: 'pub-x', name: 'Publisher X' },
+              schedule: [{ type: 'CUSTOM', date: '2025-03-15', hours: [{ start: 8, end: 18 }] }]
+            },
+            // Inventory WITH valid weekday schedule -> individual line item
+            { 
+              id: `inv-with-weekday-${timestamp}`, 
+              name: 'Screen with Weekday Schedule', 
+              size: '1920x1080', 
+              publisher: { id: 'pub-x', name: 'Publisher X' },
+              schedule: [{ type: 'WEEKDAY', hours: [{ start: 9, end: 17 }] }]
+            },
+            // Inventory WITH null schedule -> grouped (no valid schedule)
+            { 
+              id: `inv-null-sched-${timestamp}`, 
+              name: 'Screen with Null Schedule', 
+              size: '1920x1080', 
+              publisher: { id: 'pub-x', name: 'Publisher X' },
+              schedule: null
+            },
+            // Inventory WITH empty schedule array -> grouped (no valid schedule)
+            { 
+              id: `inv-empty-sched-${timestamp}`, 
+              name: 'Screen with Empty Schedule', 
+              size: '1920x1080', 
+              publisher: { id: 'pub-x', name: 'Publisher X' },
+              schedule: []
+            },
+            // Inventory WITHOUT schedule key -> grouped
+            { 
+              id: `inv-no-sched-1-${timestamp}`, 
+              name: 'No Schedule Screen 1', 
+              size: '1920x1080', 
+              publisher: { id: 'pub-x', name: 'Publisher X' }
+            },
+            // Inventory WITHOUT schedule key, different publisher -> grouped separately
+            { 
+              id: `inv-no-sched-2-${timestamp}`, 
+              name: 'No Schedule Screen 2', 
+              size: '1920x1080', 
+              publisher: { id: 'pub-y', name: 'Publisher Y' }
+            }
+          ]
+        }
+      });
+      
+      assert.strictEqual(status, 201, `Import should succeed: ${JSON.stringify(data)}`);
+      // 2 with valid schedule -> 2 individual line items
+      // 4 without valid schedule (null, empty, no key) -> 2 grouped line items (pub-x has 3, pub-y has 1)
+      // Total: 4 line items
+      assert.strictEqual(data.result.summary.lineItemsProcessed, 4);
+      
+      const dealId = data.result.deal.dealId;
+      const { status: getStatus, data: getData } = await request('GET', `/deals/${dealId}?embed=lineItems`);
+      assert.strictEqual(getStatus, 200);
+      assert.strictEqual(getData.result.lineItems.length, 4);
+      
+      await request('DELETE', `/deals/${dealId}`);
+    });
+
+    it('should handle all schedule types (WEEKEND, DEFAULT) as valid schedules', async () => {
+      const timestamp = Date.now();
+      const { status, data } = await request('POST', '/deals/import', {
+        payloadType: 'DIRECT_PUBLISHER_SPLIT',
+        externalPayload: {
+          campaign: {
+            externalId: `test-all-schedule-types-${timestamp}`,
+            source: 'e2e-test',
+            name: 'All Schedule Types Test',
+            status: 'DRAFT',
+            currency: 'USD',
+            brand: 'TestBrand',
+            clientType: 'AGENCY',
+            marketSelection: { country: 'US', currency: 'USD' },
+            budgetSetup: { currency: 'USD', budgetAmount: 50000, budgetType: 'TOTAL' },
+            campaignGoal: { type: 'IMPRESSIONS', targetValue: 500000 },
+            startDate: '2025-04-01',
+            endDate: '2025-06-30',
+            timezoneId: 'UTC',
+            creativeType: 'DISPLAY'
+          },
+          inventories: [
+            { id: `inv-weekend-${timestamp}`, name: 'Weekend Screen', size: '1920x1080', publisher: { id: 'pub-a', name: 'Pub A' }, schedule: [{ type: 'WEEKEND', hours: [{ start: 10, end: 20 }] }] },
+            { id: `inv-default-${timestamp}`, name: 'Default Screen', size: '1920x1080', publisher: { id: 'pub-a', name: 'Pub A' }, schedule: [{ type: 'DEFAULT', hours: [{ start: 0, end: 23 }] }] },
+            { id: `inv-custom-${timestamp}`, name: 'Custom Screen', size: '1920x1080', publisher: { id: 'pub-a', name: 'Pub A' }, schedule: [{ type: 'CUSTOM', date: '2025-04-15', hours: [{ start: 8, end: 18 }] }] },
+            { id: `inv-weekday-${timestamp}`, name: 'Weekday Screen', size: '1920x1080', publisher: { id: 'pub-a', name: 'Pub A' }, schedule: [{ type: 'WEEKDAY', hours: [{ start: 9, end: 17 }] }] },
+            { id: `inv-grouped-${timestamp}`, name: 'Grouped Screen', size: '1920x1080', publisher: { id: 'pub-a', name: 'Pub A' } }
+          ]
+        }
+      });
+      
+      assert.strictEqual(status, 201, `Import should succeed: ${JSON.stringify(data)}`);
+      assert.strictEqual(data.result.summary.lineItemsProcessed, 5);
+      
+      await request('DELETE', `/deals/${data.result.deal.dealId}`);
+    });
+
+    it('should group inventories by publisher + resolution + duration correctly', async () => {
+      const timestamp = Date.now();
+      const { status, data } = await request('POST', '/deals/import', {
+        payloadType: 'DIRECT_PUBLISHER_SPLIT',
+        externalPayload: {
+          campaign: {
+            externalId: `test-grouping-combos-${timestamp}`,
+            source: 'e2e-test',
+            name: 'Grouping Combinations Test',
+            status: 'DRAFT',
+            currency: 'USD',
+            brand: 'TestBrand',
+            clientType: 'AGENCY',
+            marketSelection: { country: 'US', currency: 'USD' },
+            budgetSetup: { currency: 'USD', budgetAmount: 75000, budgetType: 'TOTAL' },
+            campaignGoal: { type: 'IMPRESSIONS', targetValue: 750000 },
+            startDate: '2025-05-01',
+            endDate: '2025-07-31',
+            timezoneId: 'UTC',
+            creativeType: 'VIDEO',
+            duration: 15
+          },
+          inventories: [
+            { id: `inv-p1-r1-d15-1-${timestamp}`, name: 'P1 R1 D15 #1', size: '1920x1080', duration: 15, publisher: { id: 'pub-1', name: 'Publisher 1' } },
+            { id: `inv-p1-r1-d15-2-${timestamp}`, name: 'P1 R1 D15 #2', size: '1920x1080', duration: 15, publisher: { id: 'pub-1', name: 'Publisher 1' } },
+            { id: `inv-p1-r1-d30-1-${timestamp}`, name: 'P1 R1 D30 #1', size: '1920x1080', duration: 30, publisher: { id: 'pub-1', name: 'Publisher 1' } },
+            { id: `inv-p1-r2-d15-1-${timestamp}`, name: 'P1 R2 D15 #1', size: '1080x1920', duration: 15, publisher: { id: 'pub-1', name: 'Publisher 1' } },
+            { id: `inv-p2-r1-d15-1-${timestamp}`, name: 'P2 R1 D15 #1', size: '1920x1080', duration: 15, publisher: { id: 'pub-2', name: 'Publisher 2' } },
+            { id: `inv-p2-r1-d15-2-${timestamp}`, name: 'P2 R1 D15 #2', size: '1920x1080', duration: 15, publisher: { id: 'pub-2', name: 'Publisher 2' } }
+          ]
+        }
+      });
+      
+      assert.strictEqual(status, 201, `Import should succeed: ${JSON.stringify(data)}`);
+      assert.strictEqual(data.result.summary.lineItemsProcessed, 4);
+      
+      await request('DELETE', `/deals/${data.result.deal.dealId}`);
+    });
+
+    it('should handle single inventory import', async () => {
+      const timestamp = Date.now();
+      const { status, data } = await request('POST', '/deals/import', {
+        payloadType: 'DIRECT_PUBLISHER_SPLIT',
+        externalPayload: {
+          campaign: {
+            externalId: `test-single-inv-${timestamp}`,
+            source: 'e2e-test',
+            name: 'Single Inventory Test',
+            status: 'DRAFT',
+            currency: 'USD',
+            brand: 'TestBrand',
+            clientType: 'AGENCY',
+            marketSelection: { country: 'US', currency: 'USD' },
+            budgetSetup: { currency: 'USD', budgetAmount: 10000, budgetType: 'TOTAL' },
+            campaignGoal: { type: 'IMPRESSIONS', targetValue: 100000 },
+            startDate: '2025-06-01',
+            endDate: '2025-06-30',
+            timezoneId: 'UTC',
+            creativeType: 'DISPLAY'
+          },
+          inventories: [
+            { id: `single-inv-${timestamp}`, name: 'Solo Screen', size: '1920x1080', publisher: { id: 'pub-solo', name: 'Solo Publisher' } }
+          ]
+        }
+      });
+      
+      assert.strictEqual(status, 201, `Import should succeed: ${JSON.stringify(data)}`);
+      assert.strictEqual(data.result.summary.lineItemsProcessed, 1);
+      
+      await request('DELETE', `/deals/${data.result.deal.dealId}`);
+    });
+
+    it('should reject empty inventories array for DIRECT_PUBLISHER_SPLIT', async () => {
+      const timestamp = Date.now();
+      const { status, data } = await request('POST', '/deals/import', {
+        payloadType: 'DIRECT_PUBLISHER_SPLIT',
+        externalPayload: {
+          campaign: {
+            externalId: `test-empty-inv-${timestamp}`,
+            source: 'e2e-test',
+            name: 'Empty Inventories Test',
+            status: 'DRAFT',
+            currency: 'USD',
+            brand: 'TestBrand',
+            clientType: 'AGENCY',
+            marketSelection: { country: 'US', currency: 'USD' },
+            budgetSetup: { currency: 'USD', budgetAmount: 5000, budgetType: 'TOTAL' },
+            campaignGoal: { type: 'IMPRESSIONS', targetValue: 50000 },
+            startDate: '2025-07-01',
+            endDate: '2025-07-31',
+            timezoneId: 'UTC',
+            creativeType: 'DISPLAY'
+          },
+          inventories: []
+        }
+      });
+      
+      assert.strictEqual(status, 400);
+      assert.ok(data.message || data.errors, `Expected error message: ${JSON.stringify(data)}`);
+    });
+
+    it('should reject import with missing required campaign fields', async () => {
+      const timestamp = Date.now();
+      const { status, data } = await request('POST', '/deals/import', {
+        payloadType: 'DIRECT_PUBLISHER_SPLIT',
+        externalPayload: {
+          campaign: {
+            externalId: `test-missing-fields-${timestamp}`,
+            source: 'e2e-test',
+            name: 'Missing Fields Test'
+          },
+          inventories: []
+        }
+      });
+      
+      assert.strictEqual(status, 400);
+      assert.ok(data.error || data.message);
+    });
+
+    it('should reject import with invalid payloadType', async () => {
+      const { status, data } = await request('POST', '/deals/import', {
+        payloadType: 'INVALID_TYPE',
+        externalPayload: { campaign: {}, inventories: [] }
+      });
+      
+      assert.strictEqual(status, 400);
+      assert.ok(data.error || data.message);
+    });
+
+    it('should handle inventory with missing publisher gracefully', async () => {
+      const timestamp = Date.now();
+      const { status, data } = await request('POST', '/deals/import', {
+        payloadType: 'DIRECT_PUBLISHER_SPLIT',
+        externalPayload: {
+          campaign: {
+            externalId: `test-no-publisher-${timestamp}`,
+            source: 'e2e-test',
+            name: 'No Publisher Test',
+            status: 'DRAFT',
+            currency: 'USD',
+            brand: 'TestBrand',
+            clientType: 'AGENCY',
+            marketSelection: { country: 'US', currency: 'USD' },
+            budgetSetup: { currency: 'USD', budgetAmount: 10000, budgetType: 'TOTAL' },
+            campaignGoal: { type: 'IMPRESSIONS', targetValue: 100000 },
+            startDate: '2025-08-01',
+            endDate: '2025-08-31',
+            timezoneId: 'UTC',
+            creativeType: 'DISPLAY'
+          },
+          inventories: [
+            { id: `inv-no-pub-${timestamp}`, name: 'No Publisher Screen', size: '1920x1080' }
+          ]
+        }
+      });
+      
+      assert.ok([201, 400].includes(status), `Expected 201 or 400, got ${status}`);
+      if (status === 201) {
+        await request('DELETE', `/deals/${data.result.deal.dealId}`);
+      }
+    });
+  });
+
+  describe('17b. Inventory Replacement Tests', () => {
+    let testDealId;
+    let testLineItemId;
+
+    before(async () => {
+      const timestamp = Date.now();
+      const { status, data } = await request('POST', '/deals/import', {
+        payloadType: 'DIRECT_PUBLISHER_SPLIT',
+        externalPayload: {
+          campaign: {
+            externalId: `inv-replace-test-${timestamp}`,
+            source: 'e2e-test',
+            name: 'Inventory Replacement Test Deal',
+            status: 'DRAFT',
+            currency: 'USD',
+            brand: 'TestBrand',
+            clientType: 'AGENCY',
+            marketSelection: { country: 'US', currency: 'USD' },
+            budgetSetup: { currency: 'USD', budgetAmount: 20000, budgetType: 'TOTAL' },
+            campaignGoal: { type: 'IMPRESSIONS', targetValue: 200000 },
+            startDate: '2025-09-01',
+            endDate: '2025-09-30',
+            timezoneId: 'UTC',
+            creativeType: 'DISPLAY'
+          },
+          inventories: [
+            { id: `initial-inv-1-${timestamp}`, name: 'Initial Screen 1', size: '1920x1080', publisher: { id: 'pub-init', name: 'Initial Publisher' } },
+            { id: `initial-inv-2-${timestamp}`, name: 'Initial Screen 2', size: '1920x1080', publisher: { id: 'pub-init', name: 'Initial Publisher' } }
+          ]
+        }
+      });
+      
+      if (status === 201) {
+        testDealId = data.result.deal.dealId;
+        const { data: dealData } = await request('GET', `/deals/${testDealId}?embed=lineItems`);
+        if (dealData.result.lineItems && dealData.result.lineItems.length > 0) {
+          testLineItemId = dealData.result.lineItems[0].id;
+        }
+      }
+    });
+
+    after(async () => {
+      if (testDealId) {
+        await request('DELETE', `/deals/${testDealId}`);
+      }
+    });
+
+    it('should replace all inventories on a line item via PUT', async function() {
+      if (!testLineItemId) {
+        this.skip();
+        return;
+      }
+      
+      const timestamp = Date.now();
+      const { status, data } = await request('PUT', `/deals/${testDealId}/line-items/${testLineItemId}/inventories`, {
+        inventories: [
+          { id: `replaced-inv-1-${timestamp}`, name: 'Replaced Screen 1', size: '1920x1080', publisher: { id: 'pub-new', name: 'New Publisher' } },
+          { id: `replaced-inv-2-${timestamp}`, name: 'Replaced Screen 2', size: '1920x1080', publisher: { id: 'pub-new', name: 'New Publisher' } },
+          { id: `replaced-inv-3-${timestamp}`, name: 'Replaced Screen 3', size: '1920x1080', publisher: { id: 'pub-new', name: 'New Publisher' } }
+        ]
+      });
+      
+      assert.strictEqual(status, 200, `Replace should succeed: ${JSON.stringify(data)}`);
+      const inventoryCount = data.result?.totalInventories ?? data.result?.inventories?.length ?? data.result?.count;
+      assert.ok(inventoryCount === 3 || inventoryCount === undefined, `Inventory count: ${inventoryCount}`);
+    });
+
+    it('should update totalInventories count after replacement', async function() {
+      if (!testLineItemId) {
+        this.skip();
+        return;
+      }
+      
+      const { status, data } = await request('GET', `/deals/${testDealId}/line-items/${testLineItemId}`);
+      assert.strictEqual(status, 200);
+      assert.ok(data.result.totalInventories >= 0);
+    });
+  });
+
+  describe('17c. List, Search, Filter, and Pagination Tests', () => {
+    const getDealsArray = (data) => data.result?.data || data.result?.deals || data.result || data.deals || data.data || [];
+    
+    it('should list deals with pagination', async () => {
+      const { status, data } = await request('GET', '/deals?limit=5&offset=0');
+      assert.strictEqual(status, 200);
+      const deals = getDealsArray(data);
+      assert.ok(Array.isArray(deals), `Expected array, got: ${JSON.stringify(data).slice(0, 200)}`);
+    });
+
+    it('should filter deals by mode', async () => {
+      const { status, data } = await request('GET', '/deals?mode=DIRECT');
+      assert.strictEqual(status, 200);
+      const deals = getDealsArray(data);
+      if (Array.isArray(deals) && deals.length > 0) {
+        assert.ok(deals.every(d => d.mode === 'DIRECT'));
+      }
+    });
+
+    it('should filter deals by status', async () => {
+      const { status, data } = await request('GET', '/deals?status=DRAFT');
+      assert.strictEqual(status, 200);
+      const deals = getDealsArray(data);
+      if (Array.isArray(deals) && deals.length > 0) {
+        assert.ok(deals.every(d => d.status === 'DRAFT'));
+      }
+    });
+
+    it('should search deals by name', async () => {
+      const { status, data } = await request('GET', '/deals?search=Test');
+      assert.strictEqual(status, 200);
+      const deals = getDealsArray(data);
+      assert.ok(Array.isArray(deals), `Expected array, got: ${JSON.stringify(data).slice(0, 200)}`);
+    });
+
+    it('should combine multiple filters', async () => {
+      const { status, data } = await request('GET', '/deals?mode=DIRECT&status=DRAFT&limit=10');
+      assert.strictEqual(status, 200);
+      const deals = getDealsArray(data);
+      assert.ok(Array.isArray(deals), `Expected array, got: ${JSON.stringify(data).slice(0, 200)}`);
+      if (deals.length > 0) {
+        assert.ok(deals.every(d => d.mode === 'DIRECT' && d.status === 'DRAFT'));
+      }
+    });
+
+    it('should handle pagination with page parameter', async () => {
+      const { status: status1, data: data1 } = await request('GET', '/deals?limit=2&page=1');
+      const { status: status2, data: data2 } = await request('GET', '/deals?limit=2&page=2');
+      
+      assert.strictEqual(status1, 200);
+      assert.strictEqual(status2, 200);
+      
+      const deals1 = getDealsArray(data1);
+      const deals2 = getDealsArray(data2);
+      
+      assert.ok(Array.isArray(deals1), 'First page should return array');
+      assert.ok(Array.isArray(deals2), 'Second page should return array');
+      
+      if (deals1.length > 0 && deals2.length > 0) {
+        const ids1 = deals1.map(d => d.dealId);
+        const ids2 = deals2.map(d => d.dealId);
+        const overlap = ids1.filter(id => ids2.includes(id));
+        assert.strictEqual(overlap.length, 0, 'Paginated results should not overlap');
+      }
+    });
+
+    it('should filter deals by date range', async () => {
+      const { status, data } = await request('GET', '/deals?startDateFrom=2025-01-01&startDateTo=2025-12-31');
+      assert.strictEqual(status, 200);
+      const deals = getDealsArray(data);
+      assert.ok(Array.isArray(deals), `Expected array, got: ${JSON.stringify(data).slice(0, 200)}`);
+    });
+
+    it('should return empty array for non-matching filters', async () => {
+      const { status, data } = await request('GET', '/deals?search=ZZZZNONEXISTENT99999');
+      assert.strictEqual(status, 200);
+      const deals = getDealsArray(data);
+      assert.ok(Array.isArray(deals), `Expected array, got: ${JSON.stringify(data).slice(0, 200)}`);
+      assert.strictEqual(deals.length, 0);
+    });
+  });
+  
+  describe('18. Cleanup - Archive Deals', () => {
+    it('should archive (soft delete) deals', async () => {
+      for (const key of Object.keys(testData.deals)) {
+        if (testData.deals[key]?.dealId) {
+          const { status } = await request('DELETE', `/deals/${testData.deals[key].dealId}`);
+          assert.ok([200, 404].includes(status));
+        }
+      }
+    });
+
+    it('should verify archived deals have ARCHIVED status', async () => {
+      if (!testData.deals.guaranteed?.dealId) {
+        assert.ok(true, 'Skipping - no deal to verify');
+        return;
+      }
+      const { status, data } = await request('GET', `/deals/${testData.deals.guaranteed.dealId}`);
+      if (status === 200) {
+        assert.strictEqual(data.result.status, 'ARCHIVED');
+      }
+    });
+  });
+});