@de./sdk 1.0.5 → 2.1.0

package/src/allend/Agent/realtime.ts

@@ -0,0 +1,140 @@
+import type { OrderTrackingEvent } from '@de./types'
+import type { RTLocation, Message, Peer } from '../../types'
+import type { SocketAuthCredentials } from '../../types/auth'
+import type { AccessOptions } from '../../types/access'
+
+import io, { Socket } from 'socket.io-client'
+import AccessManager from '../Access'
+import { baseURL } from '../../baseUrl'
+
+// ─── Agent Realtime ───────────────────────────────────────────────────────────
+//
+// Socket channel for riders. Two jobs:
+//
+// 1. Order rooms — after `join(jrtoken)` (token from the platform's tracking
+//    session, role=agent) the rider streams LOCATION-CHANGE / MESSAGE into
+//    the room and receives ORDER_UPDATE events for the order.
+//
+// 2. Proactive-consolidation responses — CONSOLIDATION_ACK / NACK / POSITION
+//    go over the socket, NOT the REST respond endpoints (those serve relay
+//    and dispatch offers). See de.arch consolidation README: response channels.
+//
+// NOTE — dispatch/consolidation OFFERS do not arrive on this socket: De.
+// emits RALLY_EVENT to service connections only, and the operating platform
+// (e.g. its backend SSE) relays offers to the rider app. Respond to relayed
+// offers via `agent.dispatch.respond(...)` / `agent.consolidation.respond(...)`.
+//
+// Distinct from `Realtime` (allend/Realtime), which is the client-role socket.
+
+export type AgentRealtimeContext = {
+  wid: string
+  type: string
+  xcode: string
+}
+
+export default class AgentRealtime extends AccessManager {
+  private nsp?: Socket
+  private iosHost: string
+  private agentId?: string
+
+  constructor( access: AccessOptions ){
+    super( access, 'API' )
+
+    // Socket.io is served by the same de.arch API server, so an explicit
+    // origin governs the socket exactly as it governs the requests — without
+    // this, a client pointed at a self-hosted De. still opened its socket
+    // against the environment table's host.
+    this.iosHost = access.baseUrl?.replace( /\/+$/, '' )
+                    || baseURL('API', access.env || 'dev', access.devHostname )
+  }
+
+  connect( agentId: string ): Promise<void> {
+    return new Promise( ( resolve, reject ) => {
+      const auth: SocketAuthCredentials = {
+        utype: 'agent',
+        id: agentId,
+        remoteOrigin: this.remoteOrigin as string,
+        accessToken: this.accessToken as string
+      }
+
+      this.agentId = agentId
+      this.nsp = io( this.iosHost, { auth } )
+      this.nsp.on('connect', resolve )
+      this.nsp.on('connect_error', reject )
+    } )
+  }
+
+  disconnect(){
+    this.nsp?.disconnect()
+    return true
+  }
+
+  /**
+   * Join an order tracking room with a Join Room Token issued by
+   * GET /v1/tracking/:reference (role must match this socket's utype)
+   */
+  join( jrtoken: string ): Promise<boolean> {
+    return new Promise( ( resolve, reject ) => {
+      this.nsp?.emit('JOIN', jrtoken, ( errmess?: string ) => {
+        errmess ? reject( new Error( errmess ) ) : resolve( true )
+      } )
+    } )
+  }
+
+  // ── Order room streams (after join) ─────────────────────────────────────
+
+  sendLocation( location: RTLocation ){
+    this.nsp?.emit('LOCATION-CHANGE', location )
+    return this
+  }
+
+  sendMessage( message: Message ){
+    this.nsp?.emit('MESSAGE', message )
+    return this
+  }
+
+  onOrderUpdate( fn: ( event: OrderTrackingEvent ) => void ){
+    this.nsp?.on('ORDER_UPDATE', fn )
+    return this
+  }
+
+  onMessage( fn: ( message: Message ) => void ){
+    this.nsp?.on('MESSAGE', fn )
+    return this
+  }
+
+  onConnected( fn: ( peer: Peer ) => void ){
+    this.nsp?.on('CONNECTED', fn )
+    return this
+  }
+
+  onDisconnected( fn: ( peer: Peer ) => void ){
+    this.nsp?.on('DISCONNECTED', fn )
+    return this
+  }
+
+  // ── Proactive consolidation channel (socket-only responses) ─────────────
+
+  ackConsolidation( context: AgentRealtimeContext, offerId: string ){
+    if( !this.agentId ) throw new Error('Not connected')
+    this.nsp?.emit('CONSOLIDATION_ACK', { context, offerId, agentId: this.agentId } )
+    return this
+  }
+
+  nackConsolidation( context: AgentRealtimeContext, offerId: string, nackReason?: string ){
+    if( !this.agentId ) throw new Error('Not connected')
+    this.nsp?.emit('CONSOLIDATION_NACK', { context, offerId, agentId: this.agentId, nackReason } )
+    return this
+  }
+
+  /**
+   * Stream the rider's position into the proactive consolidation engine —
+   * feeds trajectory tracking (ARRIVED / DIVERGING / STATIONARY) for
+   * committed handoffs. Distinct from order-room sendLocation().
+   */
+  positionUpdate( context: AgentRealtimeContext, location: RTLocation, status?: string ){
+    if( !this.agentId ) throw new Error('Not connected')
+    this.nsp?.emit('CONSOLIDATION_POSITION', { context, agentId: this.agentId, location, status } )
+    return this
+  }
+}

package/src/allend/Agent/rides.ts

@@ -6,7 +6,7 @@ import type {
 	AgentRideCompleteValidation,
 	AgentRideCancelValidation
 } from '@de./types'
-import { qs, type Http, type Res } from '../../utils'
+import { qs, type Http, type Res, type Data } from '../../utils'
 
 // ─── Agent Ride Orders ────────────────────────────────────────────────────────
 
@@ -14,60 +14,48 @@ export default class AgentRides {
 	constructor( private http: Http ){}
 
 	async list( querystring?: AgentRideListValidation['querystring'] ): Promise<AgentRideListValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<AgentRideListValidation['response']>>({
+		return await this.http.request<AgentRideListValidation['response']>({
 			url: `/agent/ride/orders${qs( querystring )}`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async get( reference: string ): Promise<AgentRideGetValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<AgentRideGetValidation['response']>>({
+		return await this.http.request<AgentRideGetValidation['response']>({
 			url: `/agent/ride/orders/${reference}`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async accept( reference: string, body: AgentRideAcceptValidation['body'] ): Promise<AgentRideAcceptValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<AgentRideAcceptValidation['response']>>({
+		return await this.http.request<AgentRideAcceptValidation['response']>({
 			url: `/agent/ride/orders/${reference}/accept`,
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async start( reference: string, body: AgentRideStartValidation['body'] ): Promise<AgentRideStartValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<AgentRideStartValidation['response']>>({
+		return await this.http.request<AgentRideStartValidation['response']>({
 			url: `/agent/ride/orders/${reference}/start`,
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async complete( reference: string, body: AgentRideCompleteValidation['body'] ): Promise<AgentRideCompleteValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<AgentRideCompleteValidation['response']>>({
+		return await this.http.request<AgentRideCompleteValidation['response']>({
 			url: `/agent/ride/orders/${reference}/complete`,
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async cancel( reference: string, body: AgentRideCancelValidation['body'] ): Promise<AgentRideCancelValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<AgentRideCancelValidation['response']>>({
+		return await this.http.request<AgentRideCancelValidation['response']>({
 			url: `/agent/ride/orders/${reference}/cancel`,
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 }

package/src/allend/Agent/shipping.ts

@@ -5,7 +5,7 @@ import type {
 	AgentShippingUpdateStatusValidation,
 	AgentShippingReportIssueValidation
 } from '@de./types'
-import { qs, type Http, type Res } from '../../utils'
+import { qs, type Http, type Res, type Data } from '../../utils'
 
 // ─── Agent Shipping Orders ────────────────────────────────────────────────────
 
@@ -13,49 +13,39 @@ export default class AgentShipping {
 	constructor( private http: Http ){}
 
 	async list( querystring?: AgentShippingListValidation['querystring'] ): Promise<AgentShippingListValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<AgentShippingListValidation['response']>>({
+		return await this.http.request<AgentShippingListValidation['response']>({
 			url: `/agent/shipping/orders${qs( querystring )}`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async get( reference: string ): Promise<AgentShippingGetValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<AgentShippingGetValidation['response']>>({
+		return await this.http.request<AgentShippingGetValidation['response']>({
 			url: `/agent/shipping/orders/${reference}`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async accept( reference: string ): Promise<AgentShippingAcceptValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<AgentShippingAcceptValidation['response']>>({
+		return await this.http.request<AgentShippingAcceptValidation['response']>({
 			url: `/agent/shipping/orders/${reference}/accept`,
 			method: 'POST'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async updateStatus( reference: string, body: AgentShippingUpdateStatusValidation['body'] ): Promise<AgentShippingUpdateStatusValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<AgentShippingUpdateStatusValidation['response']>>({
+		return await this.http.request<AgentShippingUpdateStatusValidation['response']>({
 			url: `/agent/shipping/orders/${reference}/status`,
 			method: 'PATCH',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async reportIssue( reference: string, body: AgentShippingReportIssueValidation['body'] ): Promise<AgentShippingReportIssueValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<AgentShippingReportIssueValidation['response']>>({
+		return await this.http.request<AgentShippingReportIssueValidation['response']>({
 			url: `/agent/shipping/orders/${reference}/issue`,
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 }

package/src/allend/CSP/analytics.ts

@@ -6,7 +6,7 @@ import type {
 	CSPAnalyticsGetReportValidation,
 	CSPAnalyticsListReportsValidation
 } from '@de./types/csp/analytics'
-import { qs, type Http, type Res } from '../../utils'
+import { qs, type Http, type Res, type Data } from '../../utils'
 
 // ── CSP Analytics ─────────────────────────────────────────────────────────
 
@@ -14,60 +14,48 @@ export default class CSPAnalytics {
 	constructor( private http: Http ){}
 
 	async orders( body: CSPAnalyticsOrdersValidation['body'] ): Promise<CSPAnalyticsOrdersValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPAnalyticsOrdersValidation['response']>>({
+		return await this.http.request<CSPAnalyticsOrdersValidation['response']>({
 			url: '/csp/analytics/orders',
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async fulfillment( body: CSPAnalyticsFulfillmentValidation['body'] ): Promise<CSPAnalyticsFulfillmentValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPAnalyticsFulfillmentValidation['response']>>({
+		return await this.http.request<CSPAnalyticsFulfillmentValidation['response']>({
 			url: '/csp/analytics/fulfillment',
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async providers( body: CSPAnalyticsProvidersValidation['body'] ): Promise<CSPAnalyticsProvidersValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPAnalyticsProvidersValidation['response']>>({
+		return await this.http.request<CSPAnalyticsProvidersValidation['response']>({
 			url: '/csp/analytics/providers',
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async generateReport( body: CSPAnalyticsGenerateReportValidation['body'] ): Promise<CSPAnalyticsGenerateReportValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPAnalyticsGenerateReportValidation['response']>>({
+		return await this.http.request<CSPAnalyticsGenerateReportValidation['response']>({
 			url: '/csp/analytics/reports',
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async getReport( id: string ): Promise<CSPAnalyticsGetReportValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPAnalyticsGetReportValidation['response']>>({
+		return await this.http.request<CSPAnalyticsGetReportValidation['response']>({
 			url: `/csp/analytics/reports/${id}`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async listReports( querystring?: CSPAnalyticsListReportsValidation['querystring'] ): Promise<CSPAnalyticsListReportsValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPAnalyticsListReportsValidation['response']>>({
+		return await this.http.request<CSPAnalyticsListReportsValidation['response']>({
 			url: `/csp/analytics/reports${qs( querystring )}`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 }

package/src/allend/CSP/index.ts

@@ -12,6 +12,10 @@ export type CSPConfig = {
 	env?: 'dev' | 'staging' | 'prod'
 	platform?: 'web' | 'mobile' | 'server' | 'proxy'
 	remoteOrigin?: string
+	/** Per-request deadline in ms. See `AccessOptions.timeout`. */
+	timeout?: number
+	/** Explicit service origin, overriding the env table. See `AccessOptions.baseUrl`. */
+	baseUrl?: string
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -38,7 +42,9 @@ export default class CSP extends SharedContextClient<'CSP'> {
 			accessToken:  config.accessToken,
 			env:          config.env      || 'dev',
 			platform:     config.platform || 'proxy',
-			remoteOrigin: config.remoteOrigin
+			remoteOrigin: config.remoteOrigin,
+			timeout:      config.timeout,
+			baseUrl:      config.baseUrl
 		}
 		super( access, 'CSP' )
 

package/src/allend/CSP/inventory.ts

@@ -10,7 +10,7 @@ import type {
 	CSPInventoryListReservationsValidation,
 	CSPInventoryGetReservationValidation
 } from '@de./types/csp/inventory'
-import { qs, type Http, type Res } from '../../utils'
+import { qs, type Http, type Res, type Data } from '../../utils'
 
 // ── CSP Inventory ────────────────────────────────────────────────────────
 
@@ -18,99 +18,79 @@ export default class CSPInventory {
 	constructor( private http: Http ){}
 
 	async syncCatalog( body: CSPInventorySyncCatalogValidation['body'] ): Promise<CSPInventorySyncCatalogValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPInventorySyncCatalogValidation['response']>>({
+		return await this.http.request<CSPInventorySyncCatalogValidation['response']>({
 			url: '/csp/inventory/sync',
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async checkAvailability( body: CSPInventoryCheckAvailabilityValidation['body'] ): Promise<CSPInventoryCheckAvailabilityValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPInventoryCheckAvailabilityValidation['response']>>({
+		return await this.http.request<CSPInventoryCheckAvailabilityValidation['response']>({
 			url: '/csp/inventory/availability',
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async bulkPush( body: CSPInventoryBulkPushValidation['body'] ): Promise<CSPInventoryBulkPushValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPInventoryBulkPushValidation['response']>>({
+		return await this.http.request<CSPInventoryBulkPushValidation['response']>({
 			url: '/csp/inventory/bulk/push',
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async bulkPull( body: CSPInventoryBulkPullValidation['body'] ): Promise<CSPInventoryBulkPullValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPInventoryBulkPullValidation['response']>>({
+		return await this.http.request<CSPInventoryBulkPullValidation['response']>({
 			url: '/csp/inventory/bulk/pull',
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async getSyncStatus( syncId: string ): Promise<CSPInventoryGetSyncStatusValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPInventoryGetSyncStatusValidation['response']>>({
+		return await this.http.request<CSPInventoryGetSyncStatusValidation['response']>({
 			url: `/csp/inventory/sync/${syncId}`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async reserve( body: CSPInventoryReserveValidation['body'] ): Promise<CSPInventoryReserveValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPInventoryReserveValidation['response']>>({
+		return await this.http.request<CSPInventoryReserveValidation['response']>({
 			url: '/csp/inventory/reservations',
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async commit( body: CSPInventoryCommitValidation['body'] ): Promise<CSPInventoryCommitValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPInventoryCommitValidation['response']>>({
+		return await this.http.request<CSPInventoryCommitValidation['response']>({
 			url: '/csp/inventory/reservations/commit',
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async release( body: CSPInventoryReleaseValidation['body'] ): Promise<CSPInventoryReleaseValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPInventoryReleaseValidation['response']>>({
+		return await this.http.request<CSPInventoryReleaseValidation['response']>({
 			url: '/csp/inventory/reservations/release',
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async listReservations( querystring?: CSPInventoryListReservationsValidation['querystring'] ): Promise<CSPInventoryListReservationsValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPInventoryListReservationsValidation['response']>>({
+		return await this.http.request<CSPInventoryListReservationsValidation['response']>({
 			url: `/csp/inventory/reservations${qs( querystring )}`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async getReservation( id: string ): Promise<CSPInventoryGetReservationValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPInventoryGetReservationValidation['response']>>({
+		return await this.http.request<CSPInventoryGetReservationValidation['response']>({
 			url: `/csp/inventory/reservations/${id}`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 }

package/src/allend/CSP/orders.ts

@@ -13,7 +13,7 @@ import type {
 	CSPOrderSplitValidation,
 	CSPOrderUpdateStatusValidation
 } from '@de./types/csp/order'
-import { qs, type Http, type Res } from '../../utils'
+import { qs, type Http, type Res, type Data } from '../../utils'
 
 // ── CSP Orders ────────────────────────────────────────────────────────────
 
@@ -21,127 +21,101 @@ export default class CSPOrders {
 	constructor( private http: Http ){}
 
 	async create( body: CSPOrderCreateValidation['body'] ): Promise<CSPOrderCreateValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPOrderCreateValidation['response']>>({
+		return await this.http.request<CSPOrderCreateValidation['response']>({
 			url: '/csp/orders',
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async retrieve( reference: string ): Promise<CSPOrderRetrieveValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPOrderRetrieveValidation['response']>>({
+		return await this.http.request<CSPOrderRetrieveValidation['response']>({
 			url: `/csp/orders/${reference}`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async list( querystring?: CSPOrderListValidation['querystring'] ): Promise<CSPOrderListValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPOrderListValidation['response']>>({
+		return await this.http.request<CSPOrderListValidation['response']>({
 			url: `/csp/orders${qs( querystring )}`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async update( reference: string, body: CSPOrderUpdateValidation['body'] ): Promise<CSPOrderUpdateValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPOrderUpdateValidation['response']>>({
+		return await this.http.request<CSPOrderUpdateValidation['response']>({
 			url: `/csp/orders/${reference}`,
 			method: 'PATCH',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async tracking( reference: string ): Promise<CSPOrderTrackingValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPOrderTrackingValidation['response']>>({
+		return await this.http.request<CSPOrderTrackingValidation['response']>({
 			url: `/csp/orders/${reference}/tracking`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async cancel( reference: string, body: CSPOrderCancelValidation['body'] ): Promise<CSPOrderCancelValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPOrderCancelValidation['response']>>({
+		return await this.http.request<CSPOrderCancelValidation['response']>({
 			url: `/csp/orders/${reference}/cancel`,
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async timeline( reference: string ): Promise<CSPOrderTimelineValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPOrderTimelineValidation['response']>>({
+		return await this.http.request<CSPOrderTimelineValidation['response']>({
 			url: `/csp/orders/${reference}/timeline`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async reportException( reference: string, body: CSPOrderReportExceptionValidation['body'] ): Promise<CSPOrderReportExceptionValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPOrderReportExceptionValidation['response']>>({
+		return await this.http.request<CSPOrderReportExceptionValidation['response']>({
 			url: `/csp/orders/${reference}/exceptions`,
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async listExceptions( reference: string ): Promise<CSPOrderListExceptionsValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPOrderListExceptionsValidation['response']>>({
+		return await this.http.request<CSPOrderListExceptionsValidation['response']>({
 			url: `/csp/orders/${reference}/exceptions`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async resolveException( reference: string, exceptionId: string, body: CSPOrderResolveExceptionValidation['body'] ): Promise<CSPOrderResolveExceptionValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPOrderResolveExceptionValidation['response']>>({
+		return await this.http.request<CSPOrderResolveExceptionValidation['response']>({
 			url: `/csp/orders/${reference}/exceptions/${exceptionId}/resolve`,
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async dispatch( reference: string, body: CSPOrderDispatchValidation['body'] ): Promise<CSPOrderDispatchValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPOrderDispatchValidation['response']>>({
+		return await this.http.request<CSPOrderDispatchValidation['response']>({
 			url: `/csp/orders/${reference}/dispatch`,
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async split( reference: string, body: CSPOrderSplitValidation['body'] ): Promise<CSPOrderSplitValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPOrderSplitValidation['response']>>({
+		return await this.http.request<CSPOrderSplitValidation['response']>({
 			url: `/csp/orders/${reference}/split`,
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async updateStatus( reference: string, body: CSPOrderUpdateStatusValidation['body'] ): Promise<CSPOrderUpdateStatusValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<CSPOrderUpdateStatusValidation['response']>>({
+		return await this.http.request<CSPOrderUpdateStatusValidation['response']>({
 			url: `/csp/orders/${reference}/status`,
 			method: 'PATCH',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 }