@de./sdk 1.0.4 → 2.0.0

package/src/allend/Queries/pricing.ts

@@ -0,0 +1,51 @@
+import type {
+	QueryGetPricingValidation,
+	QueryEstimateCostValidation,
+	QueryComparePricingValidation,
+	QueryPricingInvalidateCacheValidation,
+	QueryPricingCacheStatsValidation
+} from '@de./types'
+import { type Http, type Res, type Data } from '../../utils'
+
+// ─── Pricing ──────────────────────────────────────────────────────────────────
+
+export class QueriesPricing {
+	constructor( private http: Http ){}
+
+	async get( lsp: string, serviceId: string ): Promise<QueryGetPricingValidation['response']> {
+		return await this.http.request<QueryGetPricingValidation['response']>({
+			url: `/queries/pricing/${lsp}/${serviceId}`,
+			method: 'GET'
+		})
+	}
+
+	async estimate( body: QueryEstimateCostValidation['body'] ): Promise<QueryEstimateCostValidation['response']> {
+		return await this.http.request<QueryEstimateCostValidation['response']>({
+			url: '/queries/pricing/estimate',
+			method: 'POST',
+			body
+		})
+	}
+
+	async compare( body: QueryComparePricingValidation['body'] ): Promise<QueryComparePricingValidation['response']> {
+		return await this.http.request<QueryComparePricingValidation['response']>({
+			url: '/queries/pricing/compare',
+			method: 'POST',
+			body
+		})
+	}
+
+	async invalidateCache( lsp: string, serviceId: string ): Promise<QueryPricingInvalidateCacheValidation['response']> {
+		return await this.http.request<QueryPricingInvalidateCacheValidation['response']>({
+			url: `/queries/pricing/cache/${lsp}/${serviceId}`,
+			method: 'DELETE'
+		})
+	}
+
+	async cacheStats(): Promise<QueryPricingCacheStatsValidation['response']> {
+		return await this.http.request<QueryPricingCacheStatsValidation['response']>({
+			url: '/queries/pricing/cache/stats',
+			method: 'GET'
+		})
+	}
+}

package/src/allend/{DClient/Event.ts → Realtime/index.ts}

@@ -1,20 +1,21 @@
-import type { RTLocation , Message, Peer, OrderStage } from '../../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'
 
-export default class Event extends AccessManager {
+export default class Realtime extends AccessManager {
   private nsp?: Socket
   private iosHost: string
 
   constructor( access: AccessOptions ){
     super( access, 'API' )
-    
     // Socket server host
-    this.iosHost = access.env == 'prod' ?
-                        'https://api.dedot.io' // Production server
-                        : 'http://api.dedot.io:24800' // Development & staging server
+    // 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> {
@@ -57,20 +58,20 @@ export default class Event extends AccessManager {
     return this
   }
 
-  onRoute( fn: ( data: any ) => void ){
-    this.nsp?.on('ROUTE-CHANGE', fn )
-    return this
-  }
-  onStage( fn: ( data: OrderStage ) => void ){
-    this.nsp?.on('STAGE-CHANGE', fn )
-    return this
-  }
-  onLocation( fn: ( location: RTLocation  ) => void ){
-    this.nsp?.on('LOCATION-CHANGE', fn )
-    return this
-  }
-  onMessage( fn: ( payload: Message ) => void ){
-    this.nsp?.on('MESSAGE', fn )
-    return this
-  }
+  // onRoute( fn: ( data: any ) => void ){
+  //   this.nsp?.on('ROUTE-CHANGE', fn )
+  //   return this
+  // }
+  // onStage( fn: ( data: OrderStage ) => void ){
+  //   this.nsp?.on('STAGE-CHANGE', fn )
+  //   return this
+  // }
+  // onLocation( fn: ( location: RTLocation  ) => void ){
+  //   this.nsp?.on('LOCATION-CHANGE', fn )
+  //   return this
+  // }
+  // onMessage( fn: ( payload: Message ) => void ){
+  //   this.nsp?.on('MESSAGE', fn )
+  //   return this
+  // }
 }

package/src/allend/Shared/account.ts

@@ -0,0 +1,24 @@
+import type {
+	SharedAccountKnowsValidation,
+	SharedAccountRetrieveValidation
+} from '@de./types/shared/account'
+import type { UserContextType } from '@de./types'
+import type { Http, Res, Data } from '../../utils'
+
+export default class SharedAccount {
+	constructor( private http: Http, private ctype: UserContextType ){}
+
+	async knows(): Promise<SharedAccountKnowsValidation['response']> {
+		return await this.http.request<SharedAccountKnowsValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/account/knows`,
+			method: 'GET'
+		})
+	}
+
+	async retrieve(): Promise<SharedAccountRetrieveValidation['response']> {
+		return await this.http.request<SharedAccountRetrieveValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/account`,
+			method: 'GET'
+		})
+	}
+}

package/src/allend/Shared/buckets.ts

@@ -0,0 +1,117 @@
+import type {
+	SharedBucketCreateValidation,
+	SharedBucketRetrieveValidation,
+	SharedBucketFetchValidation,
+	SharedBucketUpdateValidation,
+	SharedBucketRemoveValidation,
+	SharedBucketAssignValidation,
+	SharedBucketUnassignValidation,
+	SharedBucketLockOrUnlockValidation,
+	SharedBucketAddOrRemoveItemValidation,
+	SharedBucketFetchItemsValidation,
+	SharedBucketPackagedValidation
+} from '@de./types/shared/bucket'
+import type { UserContextType } from '@de./types'
+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']> {
+		return await this.http.request<SharedBucketCreateValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/buckets`,
+			method: 'POST',
+			body
+		})
+	}
+
+	async list(): Promise<SharedBucketFetchValidation['response']> {
+		return await this.http.request<SharedBucketFetchValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/buckets`,
+			method: 'GET'
+		})
+	}
+
+	async retrieve( reference: string ): Promise<SharedBucketRetrieveValidation['response']> {
+		return await this.http.request<SharedBucketRetrieveValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/buckets/${reference}`,
+			method: 'GET'
+		})
+	}
+
+	async update( reference: string, body: SharedBucketUpdateValidation['body'] ): Promise<SharedBucketUpdateValidation['response']> {
+		return await this.http.request<SharedBucketUpdateValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/buckets/${reference}`,
+			method: 'PATCH',
+			body
+		})
+	}
+
+	async remove( reference: string ): Promise<SharedBucketRemoveValidation['response']> {
+		return await this.http.request<SharedBucketRemoveValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/buckets/${reference}`,
+			method: 'DELETE'
+		})
+	}
+
+	async assign( reference: string, to: SharedBucketAssignValidation['params']['to'], body: SharedBucketAssignValidation['body'] ): Promise<SharedBucketAssignValidation['response']> {
+		return await this.http.request<SharedBucketAssignValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/buckets/${reference}/assign/${to}`,
+			method: 'POST',
+			body
+		})
+	}
+
+	async unassign( reference: string, to: SharedBucketUnassignValidation['params']['to'], body: SharedBucketUnassignValidation['body'] ): Promise<SharedBucketUnassignValidation['response']> {
+		return await this.http.request<SharedBucketUnassignValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/buckets/${reference}/unassign/${to}`,
+			method: 'POST',
+			body
+		})
+	}
+
+	async lock( reference: string ): Promise<SharedBucketLockOrUnlockValidation['response']> {
+		return await this.http.request<SharedBucketLockOrUnlockValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/buckets/${reference}/lock`,
+			method: 'PATCH'
+		})
+	}
+
+	async unlock( reference: string ): Promise<SharedBucketLockOrUnlockValidation['response']> {
+		return await this.http.request<SharedBucketLockOrUnlockValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/buckets/${reference}/unlock`,
+			method: 'PATCH'
+		})
+	}
+
+	async addItem( reference: string, body: SharedBucketAddOrRemoveItemValidation['body'] ): Promise<SharedBucketAddOrRemoveItemValidation['response']> {
+		return await this.http.request<SharedBucketAddOrRemoveItemValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/buckets/${reference}/items`,
+			method: 'POST',
+			body
+		})
+	}
+
+	async removeItem( reference: string, body: SharedBucketAddOrRemoveItemValidation['body'] ): Promise<SharedBucketAddOrRemoveItemValidation['response']> {
+		return await this.http.request<SharedBucketAddOrRemoveItemValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/buckets/${reference}/items`,
+			method: 'DELETE',
+			body
+		})
+	}
+
+	async listItems( reference: string ): Promise<SharedBucketFetchItemsValidation['response']> {
+		return await this.http.request<SharedBucketFetchItemsValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/buckets/${reference}/items`,
+			method: 'GET'
+		})
+	}
+
+	async markPackaged( reference: string, body: SharedBucketPackagedValidation['body'] ): Promise<SharedBucketPackagedValidation['response']> {
+		return await this.http.request<SharedBucketPackagedValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/buckets/${reference}/packaged`,
+			method: 'POST',
+			body
+		})
+	}
+}

package/src/allend/Shared/context.ts

@@ -0,0 +1,36 @@
+import type { AccessOptions } from '../../types/access'
+import type { UserContextType } from '@de./types'
+import AccessManager from '../Access'
+import SharedFAQs from './faqs'
+import SharedUsers from './users'
+import SharedAccount from './account'
+import SharedInvitation from './invitation'
+
+// ─────────────────────────────────────────────────────────────────────────────
+//
+// SharedContextClient: base for context-scoped service clients (LSP, DEV, CSP, IoTSP).
+//
+// Wires the shared sub-clients that de.arch reassigns under every user context
+// (faqs, users, account, invitation) — mirroring the per-service route reassignment
+// in de.arch's *(ctype) route factories. Context-selective resources — operators
+// (OperatorContextType only) and buckets — are added by the concrete client where valid.
+//
+// The public API stays flat: consumers use `client.faqs`, `client.users`, etc.
+//
+// ─────────────────────────────────────────────────────────────────────────────
+
+export default abstract class SharedContextClient<C extends UserContextType> extends AccessManager {
+	readonly faqs:       SharedFAQs
+	readonly users:      SharedUsers
+	readonly account:    SharedAccount
+	readonly invitation: SharedInvitation<C>
+
+	constructor( access: AccessOptions, ctype: C ){
+		super( access, 'API' )
+
+		this.faqs       = new SharedFAQs( this, ctype )
+		this.users      = new SharedUsers( this, ctype )
+		this.account    = new SharedAccount( this, ctype )
+		this.invitation = new SharedInvitation<C>( this, ctype )
+	}
+}

package/src/allend/Shared/faqs.ts

@@ -0,0 +1,106 @@
+import type {
+	SharedFAQAddValidation,
+	SharedFAQRetrieveValidation,
+	SharedFAQFetchValidation,
+	SharedFAQSearchValidation,
+	SharedFAQUpdateValidation,
+	SharedFAQRemoveValidation,
+	SharedFAQAddServiceContextValidation,
+	SharedFAQRemoveServiceContextValidation,
+	SharedFAQArchiveOrRestoreValidation,
+	SharedFAQLockOrUnlockValidation
+} from '@de./types/shared/faq'
+import type { UserContextType } from '@de./types'
+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']> {
+		return await this.http.request<SharedFAQAddValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/faqs`,
+			method: 'POST',
+			body
+		})
+	}
+
+	async list( querystring?: SharedFAQFetchValidation['querystring'] ): Promise<SharedFAQFetchValidation['response']> {
+		return await this.http.request<SharedFAQFetchValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/faqs${qs( querystring )}`,
+			method: 'GET'
+		})
+	}
+
+	async retrieve( reference: string ): Promise<SharedFAQRetrieveValidation['response']> {
+		return await this.http.request<SharedFAQRetrieveValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/faqs/${reference}`,
+			method: 'GET'
+		})
+	}
+
+	async search( querystring: SharedFAQSearchValidation['querystring'] ): Promise<SharedFAQSearchValidation['response']> {
+		return await this.http.request<SharedFAQSearchValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/faqs/search${qs( querystring )}`,
+			method: 'GET'
+		})
+	}
+
+	async update( reference: string, body: SharedFAQUpdateValidation['body'] ): Promise<SharedFAQUpdateValidation['response']> {
+		return await this.http.request<SharedFAQUpdateValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/faqs/${reference}`,
+			method: 'PATCH',
+			body
+		})
+	}
+
+	async remove( reference: string ): Promise<SharedFAQRemoveValidation['response']> {
+		return await this.http.request<SharedFAQRemoveValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/faqs/${reference}`,
+			method: 'DELETE'
+		})
+	}
+
+	async addServiceContext( reference: string, body: SharedFAQAddServiceContextValidation['body'] ): Promise<SharedFAQAddServiceContextValidation['response']> {
+		return await this.http.request<SharedFAQAddServiceContextValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/faqs/${reference}/context`,
+			method: 'POST',
+			body
+		})
+	}
+
+	async removeServiceContext( reference: string, body: SharedFAQRemoveServiceContextValidation['body'] ): Promise<SharedFAQRemoveServiceContextValidation['response']> {
+		return await this.http.request<SharedFAQRemoveServiceContextValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/faqs/${reference}/context`,
+			method: 'DELETE',
+			body
+		})
+	}
+
+	async archive( reference: string ): Promise<SharedFAQArchiveOrRestoreValidation['response']> {
+		return await this.http.request<SharedFAQArchiveOrRestoreValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/faqs/${reference}/archive`,
+			method: 'PATCH'
+		})
+	}
+
+	async restore( reference: string ): Promise<SharedFAQArchiveOrRestoreValidation['response']> {
+		return await this.http.request<SharedFAQArchiveOrRestoreValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/faqs/${reference}/restore`,
+			method: 'PATCH'
+		})
+	}
+
+	async lock( reference: string ): Promise<SharedFAQLockOrUnlockValidation['response']> {
+		return await this.http.request<SharedFAQLockOrUnlockValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/faqs/${reference}/lock`,
+			method: 'PATCH'
+		})
+	}
+
+	async unlock( reference: string ): Promise<SharedFAQLockOrUnlockValidation['response']> {
+		return await this.http.request<SharedFAQLockOrUnlockValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/faqs/${reference}/unlock`,
+			method: 'PATCH'
+		})
+	}
+}

package/src/allend/Shared/invitation.ts

@@ -0,0 +1,77 @@
+import type {
+	DEVSharedInvitationSendValidation,
+	DEVSharedInvitationCancelValidation,
+	DEVSharedInvitationAcceptValidation,
+	CSPSharedInvitationSendValidation,
+	CSPSharedInvitationCancelValidation,
+	CSPSharedInvitationAcceptValidation,
+	LSPSharedInvitationSendValidation,
+	LSPSharedInvitationCancelValidation,
+	LSPSharedInvitationAcceptValidation
+} from '@de./types/shared/invitation'
+import type { UserContextType } from '@de./types'
+import { type Http, type Res, type Data } from '../../utils'
+
+// ─── Validation map ───────────────────────────────────────────────────────────
+
+type InvitationV<C extends UserContextType> = {
+	DEV: {
+		send: DEVSharedInvitationSendValidation
+		cancel: DEVSharedInvitationCancelValidation
+		accept: DEVSharedInvitationAcceptValidation
+	}
+	CSP: {
+		send: CSPSharedInvitationSendValidation
+		cancel: CSPSharedInvitationCancelValidation
+		accept: CSPSharedInvitationAcceptValidation
+	}
+	LSP: {
+		send: LSPSharedInvitationSendValidation
+		cancel: LSPSharedInvitationCancelValidation
+		accept: LSPSharedInvitationAcceptValidation
+	}
+	IoTSP: {
+		send: LSPSharedInvitationSendValidation
+		cancel: LSPSharedInvitationCancelValidation
+		accept: LSPSharedInvitationAcceptValidation
+	}
+}[C]
+
+// ─── Class ────────────────────────────────────────────────────────────────────
+
+export default class SharedInvitation<C extends UserContextType> {
+	/**
+	 * Lowercased, like every other shared client.
+	 *
+	 * This one took the context type as a raw `prefix` and used it verbatim, so
+	 * an LSP client addressed `/LSP/invitation/agent` — de.arch mounts `/lsp`,
+	 * and every invitation a workspace ever sent through the SDK came back 404.
+	 */
+	constructor( private http: Http, private ctype: UserContextType ){}
+
+	private get prefix(): string { return this.ctype.toLowerCase() }
+
+	async send( as: string, body: InvitationV<C>['send']['body'] ): Promise<InvitationV<C>['send']['response']> {
+		return await this.http.request<InvitationV<C>['send']['response']>({
+			url: `/${this.prefix}/invitation/${as}`,
+			method: 'POST',
+			body
+		})
+	}
+
+	async cancel( body: InvitationV<C>['cancel']['body'] ): Promise<InvitationV<C>['cancel']['response']> {
+		return await this.http.request<InvitationV<C>['cancel']['response']>({
+			url: `/${this.prefix}/invitation/cancel`,
+			method: 'POST',
+			body
+		})
+	}
+
+	async accept( body: InvitationV<C>['accept']['body'] ): Promise<InvitationV<C>['accept']['response']> {
+		return await this.http.request<InvitationV<C>['accept']['response']>({
+			url: `/${this.prefix}/invitation/accept`,
+			method: 'POST',
+			body
+		})
+	}
+}

package/src/allend/Shared/operators.ts

@@ -0,0 +1,84 @@
+import type {
+	DEVSharedOperatorRetrieveValidation,
+	DEVSharedOperatorFetchValidation,
+	DEVSharedOperatorUpdateValidation,
+	DEVSharedOperatorRemoveValidation,
+	CSPSharedOperatorRetrieveValidation,
+	CSPSharedOperatorFetchValidation,
+	CSPSharedOperatorUpdateValidation,
+	CSPSharedOperatorRemoveValidation,
+	LSPSharedOperatorRetrieveValidation,
+	LSPSharedOperatorFetchValidation,
+	LSPSharedOperatorUpdateValidation,
+	LSPSharedOperatorRemoveValidation,
+	IoTSPSharedOperatorRetrieveValidation,
+	IoTSPSharedOperatorFetchValidation,
+	IoTSPSharedOperatorUpdateValidation,
+	IoTSPSharedOperatorRemoveValidation
+} from '@de./types/shared/operator'
+import { qs, type Http, type Res, type Data } from '../../utils'
+import type { OperatorContextType } from '@de./types'
+
+// ─── Validation map ───────────────────────────────────────────────────────────
+
+type OperatorV<C extends OperatorContextType> = {
+	DEV: {
+		retrieve: DEVSharedOperatorRetrieveValidation
+		fetch: DEVSharedOperatorFetchValidation
+		update: DEVSharedOperatorUpdateValidation
+		remove: DEVSharedOperatorRemoveValidation
+	}
+	CSP: {
+		retrieve: CSPSharedOperatorRetrieveValidation
+		fetch: CSPSharedOperatorFetchValidation
+		update: CSPSharedOperatorUpdateValidation
+		remove: CSPSharedOperatorRemoveValidation
+	}
+	LSP: {
+		retrieve: LSPSharedOperatorRetrieveValidation
+		fetch: LSPSharedOperatorFetchValidation
+		update: LSPSharedOperatorUpdateValidation
+		remove: LSPSharedOperatorRemoveValidation
+	}
+	IoTSP: {
+		retrieve: IoTSPSharedOperatorRetrieveValidation
+		fetch: IoTSPSharedOperatorFetchValidation
+		update: IoTSPSharedOperatorUpdateValidation
+		remove: IoTSPSharedOperatorRemoveValidation
+	}
+}[C]
+
+// ─── Class ────────────────────────────────────────────────────────────────────
+
+export default class SharedOperators<C extends OperatorContextType> {
+	constructor( private http: Http, private ctype: OperatorContextType ){}
+
+	async list( querystring?: OperatorV<C>['fetch']['querystring'] ): Promise<OperatorV<C>['fetch']['response']> {
+		return await this.http.request<OperatorV<C>['fetch']['response']>({
+			url: `/${this.ctype.toLowerCase()}/operators${qs( querystring )}`,
+			method: 'GET'
+		})
+	}
+
+	async retrieve( id: string ): Promise<OperatorV<C>['retrieve']['response']> {
+		return await this.http.request<OperatorV<C>['retrieve']['response']>({
+			url: `/${this.ctype.toLowerCase()}/operators/${id}`,
+			method: 'GET'
+		})
+	}
+
+	async update( id: string, body: OperatorV<C>['update']['body'] ): Promise<OperatorV<C>['update']['response']> {
+		return await this.http.request<OperatorV<C>['update']['response']>({
+			url: `/${this.ctype.toLowerCase()}/operators/${id}`,
+			method: 'PATCH',
+			body
+		})
+	}
+
+	async remove( id: string ): Promise<OperatorV<C>['remove']['response']> {
+		return await this.http.request<OperatorV<C>['remove']['response']>({
+			url: `/${this.ctype.toLowerCase()}/operators/${id}`,
+			method: 'DELETE'
+		})
+	}
+}

package/src/allend/Shared/users.ts

@@ -0,0 +1,32 @@
+import type {
+	SharedUserRetrieveValidation,
+	SharedUserFetchValidation,
+	SharedUserRemoveValidation
+} from '@de./types/shared/user'
+import type { ContextType } from '@de./types'
+import { qs, type Http, type Res, type Data } from '../../utils'
+
+export default class SharedUsers {
+	constructor( private http: Http, private ctype: ContextType ){}
+
+	async list( querystring?: SharedUserFetchValidation['querystring'] ): Promise<SharedUserFetchValidation['response']> {
+		return await this.http.request<SharedUserFetchValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/users${qs( querystring )}`,
+			method: 'GET'
+		})
+	}
+
+	async retrieve( uid: string ): Promise<SharedUserRetrieveValidation['response']> {
+		return await this.http.request<SharedUserRetrieveValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/users/${uid}`,
+			method: 'GET'
+		})
+	}
+
+	async remove( uid: string ): Promise<SharedUserRemoveValidation['response']> {
+		return await this.http.request<SharedUserRemoveValidation['response']>({
+			url: `/${this.ctype.toLowerCase()}/users/${uid}`,
+			method: 'DELETE'
+		})
+	}
+}

package/src/allend/Tracking/index.ts

@@ -0,0 +1,48 @@
+import type { AccessOptions } from '../../types/access'
+import type { SharedTrackingSessionValidation } from '@de./types/shared/tracking'
+import AccessManager from '../Access'
+import { qs, type Res, type Data } from '../../utils'
+
+export type TrackingConfig = {
+	accessToken: string
+	context: string
+	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
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+//
+// Tracking: shared tracking API — de.arch /tracking routes.
+// Issues join-room tokens for Socket.IO real-time order tracking.
+//
+// ─────────────────────────────────────────────────────────────────────────────
+
+export default class Tracking extends AccessManager {
+	constructor( config: TrackingConfig ){
+		if( !config.accessToken ) throw new Error('Undefined accessToken. See https://doc.dedot.io/sdk/auth')
+		if( !config.context )     throw new Error('Undefined context. See https://doc.dedot.io/sdk/tracking')
+
+		const access: AccessOptions = {
+			context:      config.context,
+			accessToken:  config.accessToken,
+			env:          config.env      || 'dev',
+			platform:     config.platform || 'proxy',
+			remoteOrigin: config.remoteOrigin,
+			timeout:      config.timeout,
+			baseUrl:      config.baseUrl
+		}
+		super( access, 'API' )
+	}
+
+	async getSession( reference: string, role: SharedTrackingSessionValidation['querystring']['role'] ): Promise<SharedTrackingSessionValidation['response']> {
+		return await this.request<SharedTrackingSessionValidation['response']>({
+			url: `/tracking/${reference}${qs({ role })}`,
+			method: 'GET'
+		})
+	}
+}