@de./sdk 1.0.5 → 2.1.0

package/src/allend/Queries/capacity.ts

@@ -5,7 +5,7 @@ import type {
 	QueryCapacityInvalidateCacheValidation,
 	QueryCapacityCacheStatsValidation
 } from '@de./types'
-import { type Http, type Res, qs } from '../../utils'
+import { type Http, type Res, type Data, qs } from '../../utils'
 
 // ─── Capacity ─────────────────────────────────────────────────────────────────
 
@@ -13,49 +13,39 @@ export class QueriesCapacity {
 	constructor( private http: Http ){}
 
 	async query( body: QueryCapacityValidation['body'] ): Promise<QueryCapacityValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<QueryCapacityValidation['response']>>({
+		return await this.http.request<QueryCapacityValidation['response']>({
 			url: '/queries/capacity/query',
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async batchQuery( body: QueryBatchCapacityValidation['body'] ): Promise<QueryBatchCapacityValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<QueryBatchCapacityValidation['response']>>({
+		return await this.http.request<QueryBatchCapacityValidation['response']>({
 			url: '/queries/capacity/query/batch',
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async getAll( lsp: string, serviceId: string ): Promise<QueryAllCapacitiesValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<QueryAllCapacitiesValidation['response']>>({
+		return await this.http.request<QueryAllCapacitiesValidation['response']>({
 			url: `/queries/capacity/${lsp}/${serviceId}`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async invalidateCache( lsp: string, serviceId: string, querystring?: QueryCapacityInvalidateCacheValidation['querystring'] ): Promise<QueryCapacityInvalidateCacheValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<QueryCapacityInvalidateCacheValidation['response']>>({
+		return await this.http.request<QueryCapacityInvalidateCacheValidation['response']>({
 			url: `/queries/capacity/cache/${lsp}/${serviceId}${qs( querystring )}`,
 			method: 'DELETE'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async cacheStats(): Promise<QueryCapacityCacheStatsValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<QueryCapacityCacheStatsValidation['response']>>({
+		return await this.http.request<QueryCapacityCacheStatsValidation['response']>({
 			url: '/queries/capacity/cache/stats',
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 }

package/src/allend/Queries/discovery.ts

@@ -5,7 +5,7 @@ import type {
 	QueryCountServicesValidation,
 	QueryGetServiceValidation
 } from '@de./types'
-import { type Http, type Res } from '../../utils'
+import { type Http, type Res, type Data } from '../../utils'
 
 // ─── Discovery ────────────────────────────────────────────────────────────────
 
@@ -13,51 +13,41 @@ export class QueriesDiscovery {
 	constructor( private http: Http ){}
 
 	async discover( body: QueryDiscoverValidation['body'] ): Promise<QueryDiscoverValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<QueryDiscoverValidation['response']>>({
+		return await this.http.request<QueryDiscoverValidation['response']>({
 			url: '/queries/discovery/discover',
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async advancedDiscover( body: QueryAdvancedDiscoverValidation['body'] ): Promise<QueryAdvancedDiscoverValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<QueryAdvancedDiscoverValidation['response']>>({
+		return await this.http.request<QueryAdvancedDiscoverValidation['response']>({
 			url: '/queries/discovery/discover/advanced',
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async findAvailable( body: QueryFindAvailableValidation['body'] ): Promise<QueryFindAvailableValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<QueryFindAvailableValidation['response']>>({
+		return await this.http.request<QueryFindAvailableValidation['response']>({
 			url: '/queries/discovery/available',
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async count( body: QueryCountServicesValidation['body'] ): Promise<QueryCountServicesValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<QueryCountServicesValidation['response']>>({
+		return await this.http.request<QueryCountServicesValidation['response']>({
 			url: '/queries/discovery/count',
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async get( compositeId: string ): Promise<QueryGetServiceValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<QueryGetServiceValidation['response']>>({
+		return await this.http.request<QueryGetServiceValidation['response']>({
 			url: `/queries/discovery/${compositeId}`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 }

package/src/allend/Queries/index.ts

@@ -15,6 +15,10 @@ export type QueriesConfig = {
 	env?: Env
 	platform?: Platform
 	remoteOrigin?: string
+	/** Per-request deadline in ms. See `AccessOptions.timeout`. */
+	timeout?: number
+	/** Explicit service origin, overriding the env table. See `AccessOptions.baseUrl`. */
+	baseUrl?: string
 	version?: number
 }
 
@@ -38,6 +42,8 @@ export default class Queries extends AccessManager {
 			env:          config.env      || 'dev',
 			platform:     config.platform || 'proxy',
 			remoteOrigin: config.remoteOrigin,
+			timeout:      config.timeout,
+			baseUrl:      config.baseUrl,
 			version:      config.version
 		}
 

package/src/allend/Queries/matching.ts

@@ -1,5 +1,5 @@
 import type { QueryMatchValidation } from '@de./types'
-import { type Http, type Res } from '../../utils'
+import { type Http, type Res, type Data } from '../../utils'
 
 // ─── Matching ─────────────────────────────────────────────────────────────────
 
@@ -7,12 +7,10 @@ export class QueriesMatching {
 	constructor( private http: Http ){}
 
 	async match( body: QueryMatchValidation['body'] ): Promise<QueryMatchValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<QueryMatchValidation['response']>>({
+		return await this.http.request<QueryMatchValidation['response']>({
 			url: '/queries/matching/match',
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 }

package/src/allend/Queries/performance.ts

@@ -3,7 +3,7 @@ import type {
 	QueryBatchSyncPerformanceValidation,
 	QueryGetPerformanceValidation
 } from '@de./types'
-import { type Http, type Res } from '../../utils'
+import { type Http, type Res, type Data } from '../../utils'
 
 // ─── Performance ──────────────────────────────────────────────────────────────
 
@@ -11,31 +11,25 @@ export class QueriesPerformance {
 	constructor( private http: Http ){}
 
 	async sync( body: QuerySyncPerformanceValidation['body'] ): Promise<QuerySyncPerformanceValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<QuerySyncPerformanceValidation['response']>>({
+		return await this.http.request<QuerySyncPerformanceValidation['response']>({
 			url: '/queries/performance/sync',
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async batchSync( body: QueryBatchSyncPerformanceValidation['body'] ): Promise<QueryBatchSyncPerformanceValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<QueryBatchSyncPerformanceValidation['response']>>({
+		return await this.http.request<QueryBatchSyncPerformanceValidation['response']>({
 			url: '/queries/performance/sync/batch',
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async get( lsp: string, serviceId: string ): Promise<QueryGetPerformanceValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<QueryGetPerformanceValidation['response']>>({
+		return await this.http.request<QueryGetPerformanceValidation['response']>({
 			url: `/queries/performance/${lsp}/${serviceId}`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 }

package/src/allend/Queries/pricing.ts

@@ -5,7 +5,7 @@ import type {
 	QueryPricingInvalidateCacheValidation,
 	QueryPricingCacheStatsValidation
 } from '@de./types'
-import { type Http, type Res } from '../../utils'
+import { type Http, type Res, type Data } from '../../utils'
 
 // ─── Pricing ──────────────────────────────────────────────────────────────────
 
@@ -13,49 +13,39 @@ export class QueriesPricing {
 	constructor( private http: Http ){}
 
 	async get( lsp: string, serviceId: string ): Promise<QueryGetPricingValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<QueryGetPricingValidation['response']>>({
+		return await this.http.request<QueryGetPricingValidation['response']>({
 			url: `/queries/pricing/${lsp}/${serviceId}`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async estimate( body: QueryEstimateCostValidation['body'] ): Promise<QueryEstimateCostValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<QueryEstimateCostValidation['response']>>({
+		return await this.http.request<QueryEstimateCostValidation['response']>({
 			url: '/queries/pricing/estimate',
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async compare( body: QueryComparePricingValidation['body'] ): Promise<QueryComparePricingValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<QueryComparePricingValidation['response']>>({
+		return await this.http.request<QueryComparePricingValidation['response']>({
 			url: '/queries/pricing/compare',
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async invalidateCache( lsp: string, serviceId: string ): Promise<QueryPricingInvalidateCacheValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<QueryPricingInvalidateCacheValidation['response']>>({
+		return await this.http.request<QueryPricingInvalidateCacheValidation['response']>({
 			url: `/queries/pricing/cache/${lsp}/${serviceId}`,
 			method: 'DELETE'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async cacheStats(): Promise<QueryPricingCacheStatsValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<QueryPricingCacheStatsValidation['response']>>({
+		return await this.http.request<QueryPricingCacheStatsValidation['response']>({
 			url: '/queries/pricing/cache/stats',
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 }

package/src/allend/Realtime/index.ts

@@ -4,7 +4,7 @@ import type { AccessOptions } from '../../types/access'
 
 import io, { Socket } from 'socket.io-client'
 import AccessManager from '../Access'
-import { RTS_SERVER_BASEURL } from '../../baseUrl'
+import { baseURL } from '../../baseUrl'
 
 export default class Realtime extends AccessManager {
   private nsp?: Socket
@@ -13,7 +13,9 @@ export default class Realtime extends AccessManager {
   constructor( access: AccessOptions ){
     super( access, 'API' )
     // Socket server host
-    this.iosHost = RTS_SERVER_BASEURL[ access.env ]
+    // An explicit origin governs the socket as it governs the requests.
+    this.iosHost = access.baseUrl?.replace( /\/+$/, '' )
+                    || baseURL('RTS', access.env, access.devHostname )
   }
 
   connect( clientId: string ): Promise<void> {

package/src/allend/Shared/account.ts

@@ -3,26 +3,22 @@ import type {
 	SharedAccountRetrieveValidation
 } from '@de./types/shared/account'
 import type { UserContextType } from '@de./types'
-import type { Http, Res } from '../../utils'
+import type { Http, Res, Data } from '../../utils'
 
 export default class SharedAccount {
 	constructor( private http: Http, private ctype: UserContextType ){}
 
 	async knows(): Promise<SharedAccountKnowsValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedAccountKnowsValidation['response']>>({
+		return await this.http.request<SharedAccountKnowsValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/account/knows`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async retrieve(): Promise<SharedAccountRetrieveValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedAccountRetrieveValidation['response']>>({
+		return await this.http.request<SharedAccountRetrieveValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/account`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 }

package/src/allend/Shared/buckets.ts

@@ -12,132 +12,106 @@ import type {
 	SharedBucketPackagedValidation
 } from '@de./types/shared/bucket'
 import type { UserContextType } from '@de./types'
-import { type Http, type Res } from '../../utils'
+import { type Http, type Res, type Data } from '../../utils'
 
 export default class SharedBuckets {
 	constructor( private http: Http, private ctype: UserContextType ){}
 
 	async create( body: SharedBucketCreateValidation['body'] ): Promise<SharedBucketCreateValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedBucketCreateValidation['response']>>({
+		return await this.http.request<SharedBucketCreateValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/buckets`,
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async list(): Promise<SharedBucketFetchValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedBucketFetchValidation['response']>>({
+		return await this.http.request<SharedBucketFetchValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/buckets`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async retrieve( reference: string ): Promise<SharedBucketRetrieveValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedBucketRetrieveValidation['response']>>({
+		return await this.http.request<SharedBucketRetrieveValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/buckets/${reference}`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async update( reference: string, body: SharedBucketUpdateValidation['body'] ): Promise<SharedBucketUpdateValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedBucketUpdateValidation['response']>>({
+		return await this.http.request<SharedBucketUpdateValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/buckets/${reference}`,
 			method: 'PATCH',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async remove( reference: string ): Promise<SharedBucketRemoveValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedBucketRemoveValidation['response']>>({
+		return await this.http.request<SharedBucketRemoveValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/buckets/${reference}`,
 			method: 'DELETE'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async assign( reference: string, to: SharedBucketAssignValidation['params']['to'], body: SharedBucketAssignValidation['body'] ): Promise<SharedBucketAssignValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedBucketAssignValidation['response']>>({
+		return await this.http.request<SharedBucketAssignValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/buckets/${reference}/assign/${to}`,
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async unassign( reference: string, to: SharedBucketUnassignValidation['params']['to'], body: SharedBucketUnassignValidation['body'] ): Promise<SharedBucketUnassignValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedBucketUnassignValidation['response']>>({
+		return await this.http.request<SharedBucketUnassignValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/buckets/${reference}/unassign/${to}`,
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async lock( reference: string ): Promise<SharedBucketLockOrUnlockValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedBucketLockOrUnlockValidation['response']>>({
+		return await this.http.request<SharedBucketLockOrUnlockValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/buckets/${reference}/lock`,
 			method: 'PATCH'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async unlock( reference: string ): Promise<SharedBucketLockOrUnlockValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedBucketLockOrUnlockValidation['response']>>({
+		return await this.http.request<SharedBucketLockOrUnlockValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/buckets/${reference}/unlock`,
 			method: 'PATCH'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async addItem( reference: string, body: SharedBucketAddOrRemoveItemValidation['body'] ): Promise<SharedBucketAddOrRemoveItemValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedBucketAddOrRemoveItemValidation['response']>>({
+		return await this.http.request<SharedBucketAddOrRemoveItemValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/buckets/${reference}/items`,
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async removeItem( reference: string, body: SharedBucketAddOrRemoveItemValidation['body'] ): Promise<SharedBucketAddOrRemoveItemValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedBucketAddOrRemoveItemValidation['response']>>({
+		return await this.http.request<SharedBucketAddOrRemoveItemValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/buckets/${reference}/items`,
 			method: 'DELETE',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async listItems( reference: string ): Promise<SharedBucketFetchItemsValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedBucketFetchItemsValidation['response']>>({
+		return await this.http.request<SharedBucketFetchItemsValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/buckets/${reference}/items`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async markPackaged( reference: string, body: SharedBucketPackagedValidation['body'] ): Promise<SharedBucketPackagedValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedBucketPackagedValidation['response']>>({
+		return await this.http.request<SharedBucketPackagedValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/buckets/${reference}/packaged`,
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 }

package/src/allend/Shared/faqs.ts

@@ -11,120 +11,96 @@ import type {
 	SharedFAQLockOrUnlockValidation
 } from '@de./types/shared/faq'
 import type { UserContextType } from '@de./types'
-import { qs, type Http, type Res } from '../../utils'
+import { qs, type Http, type Res, type Data } from '../../utils'
 
 export default class SharedFAQs {
 	constructor( private http: Http, private ctype: UserContextType ){}
 
 	async add( body: SharedFAQAddValidation['body'] ): Promise<SharedFAQAddValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedFAQAddValidation['response']>>({
+		return await this.http.request<SharedFAQAddValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/faqs`,
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async list( querystring?: SharedFAQFetchValidation['querystring'] ): Promise<SharedFAQFetchValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedFAQFetchValidation['response']>>({
+		return await this.http.request<SharedFAQFetchValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/faqs${qs( querystring )}`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async retrieve( reference: string ): Promise<SharedFAQRetrieveValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedFAQRetrieveValidation['response']>>({
+		return await this.http.request<SharedFAQRetrieveValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/faqs/${reference}`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async search( querystring: SharedFAQSearchValidation['querystring'] ): Promise<SharedFAQSearchValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedFAQSearchValidation['response']>>({
+		return await this.http.request<SharedFAQSearchValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/faqs/search${qs( querystring )}`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async update( reference: string, body: SharedFAQUpdateValidation['body'] ): Promise<SharedFAQUpdateValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedFAQUpdateValidation['response']>>({
+		return await this.http.request<SharedFAQUpdateValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/faqs/${reference}`,
 			method: 'PATCH',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async remove( reference: string ): Promise<SharedFAQRemoveValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedFAQRemoveValidation['response']>>({
+		return await this.http.request<SharedFAQRemoveValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/faqs/${reference}`,
 			method: 'DELETE'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async addServiceContext( reference: string, body: SharedFAQAddServiceContextValidation['body'] ): Promise<SharedFAQAddServiceContextValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedFAQAddServiceContextValidation['response']>>({
+		return await this.http.request<SharedFAQAddServiceContextValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/faqs/${reference}/context`,
 			method: 'POST',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async removeServiceContext( reference: string, body: SharedFAQRemoveServiceContextValidation['body'] ): Promise<SharedFAQRemoveServiceContextValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedFAQRemoveServiceContextValidation['response']>>({
+		return await this.http.request<SharedFAQRemoveServiceContextValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/faqs/${reference}/context`,
 			method: 'DELETE',
 			body
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async archive( reference: string ): Promise<SharedFAQArchiveOrRestoreValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedFAQArchiveOrRestoreValidation['response']>>({
+		return await this.http.request<SharedFAQArchiveOrRestoreValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/faqs/${reference}/archive`,
 			method: 'PATCH'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async restore( reference: string ): Promise<SharedFAQArchiveOrRestoreValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedFAQArchiveOrRestoreValidation['response']>>({
+		return await this.http.request<SharedFAQArchiveOrRestoreValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/faqs/${reference}/restore`,
 			method: 'PATCH'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async lock( reference: string ): Promise<SharedFAQLockOrUnlockValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedFAQLockOrUnlockValidation['response']>>({
+		return await this.http.request<SharedFAQLockOrUnlockValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/faqs/${reference}/lock`,
 			method: 'PATCH'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async unlock( reference: string ): Promise<SharedFAQLockOrUnlockValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<SharedFAQLockOrUnlockValidation['response']>>({
+		return await this.http.request<SharedFAQLockOrUnlockValidation['response']>({
 			url: `/${this.ctype.toLowerCase()}/faqs/${reference}/unlock`,
 			method: 'PATCH'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 }