@de./sdk 1.0.4 → 1.0.5

package/src/allend/CSP/inventory.ts

@@ -0,0 +1,116 @@
+import type {
+	CSPInventorySyncCatalogValidation,
+	CSPInventoryCheckAvailabilityValidation,
+	CSPInventoryBulkPushValidation,
+	CSPInventoryBulkPullValidation,
+	CSPInventoryGetSyncStatusValidation,
+	CSPInventoryReserveValidation,
+	CSPInventoryCommitValidation,
+	CSPInventoryReleaseValidation,
+	CSPInventoryListReservationsValidation,
+	CSPInventoryGetReservationValidation
+} from '@de./types/csp/inventory'
+import { qs, type Http, type Res } from '../../utils'
+
+// ── CSP Inventory ────────────────────────────────────────────────────────
+
+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']>>({
+			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']>>({
+			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']>>({
+			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']>>({
+			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']>>({
+			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']>>({
+			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']>>({
+			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']>>({
+			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']>>({
+			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']>>({
+			url: `/csp/inventory/reservations/${id}`,
+			method: 'GET'
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+}

package/src/allend/CSP/orders.ts

@@ -0,0 +1,147 @@
+import type {
+	CSPOrderCreateValidation,
+	CSPOrderRetrieveValidation,
+	CSPOrderListValidation,
+	CSPOrderUpdateValidation,
+	CSPOrderTrackingValidation,
+	CSPOrderCancelValidation,
+	CSPOrderTimelineValidation,
+	CSPOrderReportExceptionValidation,
+	CSPOrderListExceptionsValidation,
+	CSPOrderResolveExceptionValidation,
+	CSPOrderDispatchValidation,
+	CSPOrderSplitValidation,
+	CSPOrderUpdateStatusValidation
+} from '@de./types/csp/order'
+import { qs, type Http, type Res } from '../../utils'
+
+// ── CSP Orders ────────────────────────────────────────────────────────────
+
+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']>>({
+			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']>>({
+			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']>>({
+			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']>>({
+			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']>>({
+			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']>>({
+			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']>>({
+			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']>>({
+			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']>>({
+			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']>>({
+			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']>>({
+			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']>>({
+			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']>>({
+			url: `/csp/orders/${reference}/status`,
+			method: 'PATCH',
+			body
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+}

package/src/allend/CSP/webhooks.ts

@@ -0,0 +1,82 @@
+import type {
+	CSPWebhookCreateValidation,
+	CSPWebhookListValidation,
+	CSPWebhookRetrieveValidation,
+	CSPWebhookUpdateValidation,
+	CSPWebhookRemoveValidation,
+	CSPWebhookLogsValidation,
+	CSPWebhookTestValidation
+} from '@de./types/csp/webhook'
+import { qs, type Http, type Res } from '../../utils'
+
+// ── CSP Webhooks ──────────────────────────────────────────────────────────
+
+export default class CSPWebhooks {
+	constructor( private http: Http ){}
+
+	async create( body: CSPWebhookCreateValidation['body'] ): Promise<CSPWebhookCreateValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<CSPWebhookCreateValidation['response']>>({
+			url: '/csp/webhooks',
+			method: 'POST',
+			body
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async list( querystring?: CSPWebhookListValidation['querystring'] ): Promise<CSPWebhookListValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<CSPWebhookListValidation['response']>>({
+			url: `/csp/webhooks${qs( querystring )}`,
+			method: 'GET'
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async retrieve( id: string ): Promise<CSPWebhookRetrieveValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<CSPWebhookRetrieveValidation['response']>>({
+			url: `/csp/webhooks/${id}`,
+			method: 'GET'
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async update( id: string, body: CSPWebhookUpdateValidation['body'] ): Promise<CSPWebhookUpdateValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<CSPWebhookUpdateValidation['response']>>({
+			url: `/csp/webhooks/${id}`,
+			method: 'PATCH',
+			body
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async remove( id: string ): Promise<CSPWebhookRemoveValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<CSPWebhookRemoveValidation['response']>>({
+			url: `/csp/webhooks/${id}`,
+			method: 'DELETE'
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async logs( id: string, querystring?: CSPWebhookLogsValidation['querystring'] ): Promise<CSPWebhookLogsValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<CSPWebhookLogsValidation['response']>>({
+			url: `/csp/webhooks/${id}/logs${qs( querystring )}`,
+			method: 'GET'
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async test( id: string, body?: CSPWebhookTestValidation['body'] ): Promise<CSPWebhookTestValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<CSPWebhookTestValidation['response']>>({
+			url: `/csp/webhooks/${id}/test`,
+			method: 'POST',
+			body
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+}

package/src/allend/Customer/index.ts

@@ -0,0 +1,44 @@
+import type { AccessOptions } from '../../types/access'
+import AccessManager from '../Access'
+import CustomerIntents from './intents'
+import CustomerOrders from './orders'
+import CustomerRides from './rides'
+
+export type CustomerConfig = {
+	context: string
+	accessToken: string
+	env?: 'dev' | 'staging' | 'prod'
+	platform?: 'web' | 'mobile' | 'server' | 'proxy'
+	remoteOrigin?: string
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+//
+// Customer: Customer Operation Interfaces — de.arch AUX/customer routes.
+// Covers intents, orders, and rides.
+//
+// ─────────────────────────────────────────────────────────────────────────────
+
+export default class Customer extends AccessManager {
+	intents: CustomerIntents
+	orders: CustomerOrders
+	rides: CustomerRides
+
+	constructor( config: CustomerConfig ){
+		if( !config.context )     throw new Error('Undefined context. See https://doc.dedot.io/sdk/aux')
+		if( !config.accessToken ) throw new Error('Undefined accessToken. See https://doc.dedot.io/sdk/auth')
+
+		const access: AccessOptions = {
+			context:      config.context,
+			accessToken:  config.accessToken,
+			env:          config.env      || 'dev',
+			platform:     config.platform || 'proxy',
+			remoteOrigin: config.remoteOrigin
+		}
+		super( access, 'API' )
+
+		this.intents = new CustomerIntents( this )
+		this.orders  = new CustomerOrders( this )
+		this.rides   = new CustomerRides( this )
+	}
+}

package/src/allend/Customer/intents.ts

@@ -0,0 +1,78 @@
+import type {
+	CustomerIntentCreateValidation,
+	CustomerIntentGetValidation,
+	CustomerIntentAddWaypointsValidation,
+	CustomerIntentAddPackagesValidation,
+	CustomerIntentSubmitValidation,
+	CustomerIntentCancelValidation
+} from '@de./types'
+import { type Http, type Res } from '../../utils'
+
+// ─── Customer Intents ─────────────────────────────────────────────────────────
+
+export default class CustomerIntents {
+	constructor( private http: Http ){}
+
+	async create( body: CustomerIntentCreateValidation['body'] ): Promise<CustomerIntentCreateValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<CustomerIntentCreateValidation['response']>>({
+			url: '/customer/intents',
+			method: 'POST',
+			body
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async get( intentToken: string ): Promise<CustomerIntentGetValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<CustomerIntentGetValidation['response']>>({
+			url: '/customer/intents',
+			method: 'GET',
+			headers: { 'x-intent-token': intentToken }
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async addWaypoints( intentToken: string, body: CustomerIntentAddWaypointsValidation['body'] ): Promise<CustomerIntentAddWaypointsValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<CustomerIntentAddWaypointsValidation['response']>>({
+			url: '/customer/intents/waypoints',
+			method: 'POST',
+			headers: { 'x-intent-token': intentToken },
+			body
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async addPackages( intentToken: string, body: CustomerIntentAddPackagesValidation['body'] ): Promise<CustomerIntentAddPackagesValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<CustomerIntentAddPackagesValidation['response']>>({
+			url: '/customer/intents/packages',
+			method: 'POST',
+			headers: { 'x-intent-token': intentToken },
+			body
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async submit( intentToken: string, body: CustomerIntentSubmitValidation['body'] ): Promise<CustomerIntentSubmitValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<CustomerIntentSubmitValidation['response']>>({
+			url: '/customer/intents/submit',
+			method: 'POST',
+			headers: { 'x-intent-token': intentToken },
+			body
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async cancel( intentToken: string ): Promise<CustomerIntentCancelValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<CustomerIntentCancelValidation['response']>>({
+			url: '/customer/intents',
+			method: 'DELETE',
+			headers: { 'x-intent-token': intentToken }
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+}

package/src/allend/Customer/orders.ts

@@ -0,0 +1,61 @@
+import type {
+	CustomerOrderListValidation,
+	CustomerOrderGetValidation,
+	CustomerOrderTrackingValidation,
+	CustomerOrderCancelValidation,
+	CustomerOrderRatingValidation
+} from '@de./types'
+import { qs, type Http, type Res } from '../../utils'
+
+// ─── Customer Orders ──────────────────────────────────────────────────────────
+
+export default class CustomerOrders {
+	constructor( private http: Http ){}
+
+	async list( querystring?: CustomerOrderListValidation['querystring'] ): Promise<CustomerOrderListValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<CustomerOrderListValidation['response']>>({
+			url: `/customer/orders${qs( querystring )}`,
+			method: 'GET'
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async get( reference: string, querystring?: CustomerOrderGetValidation['querystring'] ): Promise<CustomerOrderGetValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<CustomerOrderGetValidation['response']>>({
+			url: `/customer/orders/${reference}${qs( querystring )}`,
+			method: 'GET'
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async tracking( reference: string ): Promise<CustomerOrderTrackingValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<CustomerOrderTrackingValidation['response']>>({
+			url: `/customer/orders/${reference}/tracking`,
+			method: 'GET'
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async cancel( reference: string, body: CustomerOrderCancelValidation['body'] ): Promise<CustomerOrderCancelValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<CustomerOrderCancelValidation['response']>>({
+			url: `/customer/orders/${reference}/cancel`,
+			method: 'POST',
+			body
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async rating( reference: string, body: CustomerOrderRatingValidation['body'] ): Promise<CustomerOrderRatingValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<CustomerOrderRatingValidation['response']>>({
+			url: `/customer/orders/${reference}/rating`,
+			method: 'POST',
+			body
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+}

package/src/allend/Customer/rides.ts

@@ -0,0 +1,72 @@
+import type {
+	CustomerRideRequestValidation,
+	CustomerRideListValidation,
+	CustomerRideGetValidation,
+	CustomerRideTrackingValidation,
+	CustomerRideCancelValidation,
+	CustomerRideRatingValidation
+} from '@de./types'
+import { qs, type Http, type Res } from '../../utils'
+
+// ─── Customer Rides ───────────────────────────────────────────────────────────
+
+export default class CustomerRides {
+	constructor( private http: Http ){}
+
+	async request( body: CustomerRideRequestValidation['body'] ): Promise<CustomerRideRequestValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<CustomerRideRequestValidation['response']>>({
+			url: '/customer/rides',
+			method: 'POST',
+			body
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async list( querystring?: CustomerRideListValidation['querystring'] ): Promise<CustomerRideListValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<CustomerRideListValidation['response']>>({
+			url: `/customer/rides${qs( querystring )}`,
+			method: 'GET'
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async get( reference: string ): Promise<CustomerRideGetValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<CustomerRideGetValidation['response']>>({
+			url: `/customer/rides/${reference}`,
+			method: 'GET'
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async tracking( reference: string ): Promise<CustomerRideTrackingValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<CustomerRideTrackingValidation['response']>>({
+			url: `/customer/rides/${reference}/tracking`,
+			method: 'GET'
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async cancel( reference: string, body: CustomerRideCancelValidation['body'] ): Promise<CustomerRideCancelValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<CustomerRideCancelValidation['response']>>({
+			url: `/customer/rides/${reference}/cancel`,
+			method: 'POST',
+			body
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async rating( reference: string, body: CustomerRideRatingValidation['body'] ): Promise<CustomerRideRatingValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<CustomerRideRatingValidation['response']>>({
+			url: `/customer/rides/${reference}/rating`,
+			method: 'POST',
+			body
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+}

package/src/allend/DEV/developers.ts

@@ -0,0 +1,48 @@
+import type {
+	DEVDeveloperRetrieveValidation,
+	DEVDeveloperFetchValidation,
+	DEVDeveloperUpdateValidation
+} from '@de./types/dev/developer'
+import { type Http, type Res } from '../../utils'
+
+// ── DEV Developers ──────────────────────────────────────────────────────────────
+
+export default class DEVDevelopers {
+	constructor( private http: Http ){}
+
+	async list(): Promise<DEVDeveloperFetchValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<DEVDeveloperFetchValidation['response']>>({
+			url: '/dev/developers',
+			method: 'GET'
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async retrieve( id: string ): Promise<DEVDeveloperRetrieveValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<DEVDeveloperRetrieveValidation['response']>>({
+			url: `/dev/developers/${id}`,
+			method: 'GET'
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async update( id: string, body: DEVDeveloperUpdateValidation['body'] ): Promise<DEVDeveloperUpdateValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<DEVDeveloperUpdateValidation['response']>>({
+			url: `/dev/developers/${id}`,
+			method: 'PATCH',
+			body
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async remove( id: string ): Promise<void> {
+		const { error, message } = await this.http.request<Res<unknown>>({
+			url: `/dev/developers/${id}`,
+			method: 'DELETE'
+		})
+		if( error ) throw new Error( message )
+	}
+}