@proxima-nexus/sdk-typescript 2.0.0 → 2.1.0

package/CHANGELOG.md

@@ -5,6 +5,31 @@ All notable changes to the Proxima Nexus TypeScript SDK are documented in this f
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.1.0] - 2025-01-30
+
+### Added
+
+- **Enhanced Client** (`EnhancedProximaNexusClient`) – Higher-level API that wraps the base client with:
+  - **Simplified method signatures** – No `RawAxiosRequestConfig`; `requesterUserId` instead of `xProximaNexusRequesterUserId`
+  - **Unwrapped return values** – Methods return `Promise<T>` (e.g. `UserDto`) instead of Axios response; no `.data` needed
+  - **Domain-focused methods** – e.g. `getUser`, `getFriends`, `sendFriendRequest`, `acceptFriendRequest`, `searchByDisplayName`, `searchByRadius`, `searchByBoundingBox`
+  - **Friend workflow** – `sendFriendRequest`, `acceptFriendRequest`, `declineFriendRequest`, `removeFriend`, `getFriends`, `getPendingFriendRequests`
+  - **Blocking** – `blockUser`, `unblockUser`, `getBlockedUsers`
+  - **Event attendee/role** – `addAttendee`, `removeAttendee`, `getAttendees`, `promoteToAdmin`, `demoteToAttendee`, `getAdmins`, `getOwner`
+  - **Group membership** – `joinGroup`, `leaveGroup`, `approveMember`, `rejectMember`, `removeMember`, `getMembers`, `getPendingMembers`, `promoteToAdmin`, `demoteToMember`, `getAdmins`, `getOwner`
+- **Custom errors** – `NotFoundError`, `UnauthorizedError`, `ValidationError` (thrown instead of raw Axios errors when using the enhanced client)
+- **Base client access** – `client.base` on `EnhancedProximaNexusClient` for direct access to `UserApi`, `EventApi`, `GroupApi` when needed
+
+### Changed
+
+- None; base client API is unchanged. Enhanced client is additive.
+
+## [2.0.1] - 2025-01-29
+
+### Changed
+
+- Updated README.md to reflect version 2.0.0 API changes, including method renames, updated method signatures, and connection operation examples
+
 ## [2.0.0] - 2025-01-29
 
 ### Breaking Changes

package/README.md

@@ -2,115 +2,147 @@
 
 TypeScript SDK for the Proxima Nexus Data Plane API.
 
+> **Note:** Version 2.0.0 introduced breaking changes. See [CHANGELOG.md](./CHANGELOG.md) for migration details. Version 2.1.0 adds an **Enhanced Client** with a simplified, domain-driven API.
+
 ## Installation
 
 ```bash
 npm install @proxima-nexus/sdk-typescript
 ```
 
+## Client Options
+
+The SDK provides two client options:
+
+- **ProximaNexusClient** (base) – Direct mapping to the Data Plane API. Returns Axios promises; you use `.data` on responses.
+- **EnhancedProximaNexusClient** – Higher-level API with simpler method names, unwrapped return values (no `.data`), and domain helpers (e.g. `getFriends`, `searchByDisplayName`). Use `client.base` when you need the raw APIs.
+
 ## Usage
 
-### Basic Setup
+### Basic Setup (Base Client)
 
 ```typescript
 import { ProximaNexusClient } from '@proxima-nexus/sdk-typescript';
 
-// Initialize client
 const client = new ProximaNexusClient({
   apiKey: process.env.PROXIMA_NEXUS_API_KEY!,
   baseURL: 'https://api.proxima-nexus.com',
 });
 ```
 
-### User Operations
+### Enhanced Client (Recommended for New Code)
+
+```typescript
+import { EnhancedProximaNexusClient } from '@proxima-nexus/sdk-typescript';
+
+const client = new EnhancedProximaNexusClient({
+  apiKey: process.env.PROXIMA_NEXUS_API_KEY!,
+  baseURL: 'https://api.proxima-nexus.com',
+});
+
+// Methods return unwrapped data (no .data)
+const user = await client.users.getUser('user-123', 'requester-123'); // UserDto
+const friends = await client.users.getFriends('user-123');           // UserEntityConnectionDto[]
+const users = await client.users.searchByDisplayName('John', undefined, 10);
+
+// Friend workflow
+await client.users.sendFriendRequest('alice-id', 'bob-id');
+await client.users.acceptFriendRequest('bob-id', 'alice-id');
+await client.users.removeFriend('alice-id', 'bob-id');
+
+// Access raw APIs when needed
+const rawResponse = await client.base.users.get('user-123');
+```
+
+### User Operations (Base Client)
 
 ```typescript
 async function main() {
   try {
     // Create a user
     const createResponse = await client.users.create({
-      createUserDto: {
-        userId: 'user-123',
-        displayName: 'John Doe',
-        requesterUserId: 'requester-123',
-        visibility: 'public',
-        gender: 'male',
-        birthDate: '1990-01-01',
-        location: {
-          latitude: 40.7128,
-          longitude: -74.006,
-          name: 'New York, NY'
-        }
-      },
+      userId: 'user-123',
+      displayName: 'John Doe',
+      visibility: 'public',
+      gender: 'male',
+      birthDate: '1990-01-01',
+      location: {
+        latitude: 40.7128,
+        longitude: -74.006,
+        name: 'New York, NY'
+      }
     });
     console.log('Created user:', createResponse.data);
 
     // Search users
-    const searchResponse = await client.users.search({
-      displayName: 'John',
-      latitude: 40.7128,
-      longitude: -74.006,
-      radius: 5000,
-      limit: 10,
-    });
+    const searchResponse = await client.users.search(
+      'John', // displayName
+      40.7128, // latitude
+      -74.006, // longitude
+      5000, // radius
+      undefined, // minLatitude
+      undefined, // maxLatitude
+      undefined, // minLongitude
+      undefined, // maxLongitude
+      10, // limit
+      'requester-123' // xProximaNexusRequesterUserId (optional)
+    );
     console.log('Found users:', searchResponse.data);
 
     // Get user by ID
-    const user = await client.users.findOne({
-      userId: 'user-123',
-    });
+    const user = await client.users.get('user-123', 'requester-123');
     console.log('User details:', user.data);
 
     // Update a user
-    const updated = await client.users.update({
-      userId: 'user-123',
-      updateUserDto: {
-        requesterUserId: 'requester-123',
+    const updated = await client.users.update(
+      'user-123',
+      'requester-123',
+      {
         displayName: 'John Smith',
         gender: 'male',
         birthDate: '1990-01-01',
-      },
-    });
+      }
+    );
     console.log('Updated user:', updated.data);
 
     // Delete a user
-    await client.users.remove({
-      userId: 'user-123',
-    });
+    await client.users.remove('user-123', 'requester-123');
 
     // Get a batch of users
-    const batchUsers = await client.users.getBatch({
-      getUsersDto: {
-        userIds: ['user-1', 'user-2', 'user-3'],
-      },
-    });
+    const batchUsers = await client.users.getBatch(
+      { userIds: ['user-1', 'user-2', 'user-3'] },
+      'requester-123'
+    );
     console.log('Batch users:', batchUsers.data);
 
-    // Friend operations
-    const friends = await client.users.getFriends({
-      userId: 'user-123',
-    });
-    console.log('Friends:', friends.data);
-
-    await client.users.addFriend({
-      userId: 'user-123',
-      friendUserId: 'friend-456',
-    });
-
-    await client.users.removeFriend({
-      userId: 'user-123',
-      friendUserId: 'friend-456',
-    });
+    // Connection operations
+    const connections = await client.users.getConnections(
+      'user-123',
+      undefined, // state filter (optional)
+      undefined, // type filter (optional)
+      'requester-123' // xProximaNexusRequesterUserId (optional)
+    );
+    console.log('Connections:', connections.data);
+
+    await client.users.putConnection(
+      'user-123',
+      'friend-456',
+      'requester-123',
+      { type: 'friend' } // MutateUserConnectionDto
+    );
+
+    await client.users.deleteConnection(
+      'user-123',
+      'friend-456',
+      'friend', // type: 'friend' | 'blocked'
+      'requester-123'
+    );
 
     // Get user's groups and events
-    const groups = await client.users.getGroups({
-      userId: 'user-123',
-    });
+    const groups = await client.users.getGroups('user-123', 'requester-123');
     console.log('User groups:', groups.data);
 
-    const events = await client.users.getEvents({
-      userId: 'user-123',
-    });
+    const events = await client.users.getEvents('user-123', 'requester-123');
     console.log('User events:', events.data);
   } catch (error: any) {
     console.error('API Error:', error.message);
@@ -122,84 +154,91 @@ async function main() {
 }
 ```
 
-### Event Operations
+### Event Operations (Base Client)
 
 ```typescript
 async function main() {
   try {
     // Create an event
     const event = await client.events.create({
-      createEventDto: {
-        eventId: 'event-123',
-        displayName: 'Tech Meetup',
-        requesterUserId: 'user-123',
-        visibility: 'public',
-        startTime: '2024-12-01T18:00:00Z',
-        endTime: '2024-12-01T22:00:00Z',
-        type: 'meetup',
-        location: {
-          latitude: 40.7128,
-          longitude: -74.006,
-          name: 'New York, NY'
-        },
-        description: 'Monthly tech meetup',
+      eventId: 'event-123',
+      displayName: 'Tech Meetup',
+      visibility: 'public',
+      startTime: '2024-12-01T18:00:00Z',
+      endTime: '2024-12-01T22:00:00Z',
+      type: 'meetup',
+      location: {
+        latitude: 40.7128,
+        longitude: -74.006,
+        name: 'New York, NY'
       },
+      description: 'Monthly tech meetup',
     });
     console.log('Created event:', event.data);
 
     // Search events
-    const events = await client.events.search({
-      displayName: 'Tech',
-      latitude: 40.7128,
-      longitude: -74.006,
-      radius: 10000,
-      limit: 50,
-    });
+    const events = await client.events.search(
+      'Tech', // displayName
+      40.7128, // latitude
+      -74.006, // longitude
+      10000, // radius
+      undefined, // minLatitude
+      undefined, // maxLatitude
+      undefined, // minLongitude
+      undefined, // maxLongitude
+      50, // limit
+      'user-123' // xProximaNexusRequesterUserId (optional)
+    );
     console.log('Found events:', events.data);
 
     // Get an event by ID
-    const eventDetails = await client.events.findOne({
-      eventId: 'event-123',
-    });
+    const eventDetails = await client.events.get('event-123', 'user-123');
     console.log('Event details:', eventDetails.data);
 
     // Update an event
-    const updatedEvent = await client.events.update({
-      eventId: 'event-123',
-      updateEventDto: {
-        requesterUserId: 'user-123',
+    const updatedEvent = await client.events.update(
+      'event-123',
+      'user-123',
+      {
         displayName: 'Tech Meetup 2024',
         startTime: '2024-12-01T18:00:00Z',
         endTime: '2024-12-01T23:00:00Z',
         type: 'meetup',
-      },
-    });
+      }
+    );
     console.log('Updated event:', updatedEvent.data);
 
     // Delete an event
-    await client.events.remove({
-      eventId: 'event-123',
-      requesterUserId: 'user-123',
-    });
+    await client.events.remove('event-123', 'user-123');
 
     // Get a batch of events
-    const batchEvents = await client.events.getBatch({
-      getEventsDto: {
-        eventIds: ['event-1', 'event-2', 'event-3'],
-      },
-    });
+    const batchEvents = await client.events.getBatch(
+      { eventIds: ['event-1', 'event-2', 'event-3'] },
+      'user-123'
+    );
     console.log('Batch events:', batchEvents.data);
 
-    // Attendee operations
-    const attendees = await client.events.getAttendees({
-      eventId: 'event-123',
-    });
-    console.log('Attendees:', attendees.data);
-
-    await client.events.addAttendee({
-      eventId: 'event-123',
-      userId: 'user-456',
-    });
+    // Connection operations
+    const connections = await client.events.getConnections(
+      'event-123',
+      undefined, // type filter (optional)
+      'user-123' // xProximaNexusRequesterUserId (optional)
+    );
+    console.log('Connections:', connections.data);
+
+    await client.events.addConnection(
+      'event-123',
+      'user-456',
+      'user-123',
+      { type: 'attendee' } // MutateEventEntityConnectionDto
+    );
+
+    await client.events.removeConnection(
+      'event-123',
+      'user-456',
+      'user-123',
+      { type: 'attendee' } // MutateEventEntityConnectionDto
+    );
   } catch (error: any) {
     console.error('API Error:', error.message);
     if (error.response) {
@@ -210,85 +249,86 @@ async function main() {
 }
 ```
 
-### Group Operations
+### Group Operations (Base Client)
 
 ```typescript
 async function main() {
   try {
     // Create a group
     const group = await client.groups.create({
-      createGroupDto: {
-        groupId: 'group-123',
-        displayName: 'Music Lovers',
-        requesterUserId: 'user-123',
-        visibility: 'public',
-        type: 'club',
-        description: 'A group for music enthusiasts',
-      },
+      groupId: 'group-123',
+      displayName: 'Music Lovers',
+      visibility: 'public',
+      type: 'open', // enum: 'open' | 'request' | 'invite'
+      description: 'A group for music enthusiasts',
     });
     console.log('Created group:', group.data);
 
     // Search groups
-    const groups = await client.groups.search({
-      displayName: 'Music',
-      latitude: 40.7128,
-      longitude: -74.006,
-      radius: 5000,
-      limit: 100,
-    });
+    const groups = await client.groups.search(
+      'Music', // displayName
+      40.7128, // latitude
+      -74.006, // longitude
+      5000, // radius
+      undefined, // minLatitude
+      undefined, // maxLatitude
+      undefined, // minLongitude
+      undefined, // maxLongitude
+      100, // limit
+      'user-123' // xProximaNexusRequesterUserId (optional)
+    );
     console.log('Found groups:', groups.data);
 
     // Get a group by ID
-    const groupDetails = await client.groups.findOne({
-      groupId: 'group-123',
-    });
+    const groupDetails = await client.groups.get('group-123', 'user-123');
     console.log('Group details:', groupDetails.data);
 
     // Update a group
-    const updatedGroup = await client.groups.update({
-      groupId: 'group-123',
-      updateGroupDto: {
-        requesterUserId: 'user-123',
+    const updatedGroup = await client.groups.update(
+      'group-123',
+      'user-123',
+      {
         displayName: 'Music Enthusiasts',
-        type: 'club',
-      },
-    });
+        type: 'open',
+      }
+    );
     console.log('Updated group:', updatedGroup.data);
 
     // Delete a group
-    await client.groups.remove({
-      groupId: 'group-123',
-      requesterUserId: 'user-123',
-    });
+    await client.groups.remove('group-123', 'user-123');
 
     // Get a batch of groups
-    const batchGroups = await client.groups.getBatch({
-      getGroupsDto: {
-        groupIds: ['group-1', 'group-2', 'group-3'],
-      },
-    });
+    const batchGroups = await client.groups.getBatch(
+      { groupIds: ['group-1', 'group-2', 'group-3'] },
+      'user-123'
+    );
     console.log('Batch groups:', batchGroups.data);
 
-    // Member operations
-    const members = await client.groups.getMembers({
-      groupId: 'group-123',
-    });
-    console.log('Members:', members.data);
-
-    await client.groups.addMember({
-      groupId: 'group-123',
-      userId: 'user-456',
-    });
-
-    await client.groups.removeMember({
-      groupId: 'group-123',
-      userId: 'user-456',
-    });
+    // Connection operations
+    const connections = await client.groups.getConnections(
+      'group-123',
+      undefined, // state filter (optional)
+      undefined, // type filter (optional)
+      'user-123' // xProximaNexusRequesterUserId (optional)
+    );
+    console.log('Connections:', connections.data);
+
+    await client.groups.addConnection(
+      'group-123',
+      'user-456',
+      'user-123',
+      { type: 'member' } // MutateGroupEntityConnectionDto
+    );
+
+    await client.groups.removeConnection(
+      'group-123',
+      'user-456',
+      'user-123',
+      { type: 'member' } // MutateGroupEntityConnectionDto
+    );
 
     // Get group's events
-    const groupEvents = await client.groups.getEvents({
-      groupId: 'group-123',
-    });
+    const groupEvents = await client.groups.getEvents('group-123', 'user-123');
     console.log('Group events:', groupEvents.data);
   } catch (error: any) {
     console.error('API Error:', error.message);
@@ -300,6 +340,22 @@ async function main() {
 }
 ```
 
+## Enhanced Client API Overview
+
+The enhanced client exposes domain-focused methods:
+
+**Users:** `getUser`, `getUsers`, `createUser`, `updateUser`, `deleteUser`, `searchByDisplayName`, `searchByRadius`, `searchByBoundingBox`, `sendFriendRequest`, `acceptFriendRequest`, `declineFriendRequest`, `removeFriend`, `getFriends`, `getPendingFriendRequests`, `blockUser`, `unblockUser`, `getBlockedUsers`, `getEvents`, `getGroups`
+
+**Events:** `getEvent`, `getEvents`, `createEvent`, `updateEvent`, `deleteEvent`, `searchByDisplayName`, `searchByRadius`, `searchByBoundingBox`, `addAttendee`, `removeAttendee`, `getAttendees`, `promoteToAdmin`, `demoteToAttendee`, `getAdmins`, `getOwner`
+
+**Groups:** `getGroup`, `getGroups`, `createGroup`, `updateGroup`, `deleteGroup`, `searchByDisplayName`, `searchByRadius`, `searchByBoundingBox`, `joinGroup`, `leaveGroup`, `approveMember`, `rejectMember`, `removeMember`, `getMembers`, `getPendingMembers`, `promoteToAdmin`, `demoteToMember`, `getAdmins`, `getOwner`, `getEvents`
+
+Errors from the enhanced client are thrown as `NotFoundError`, `UnauthorizedError`, or `ValidationError` (see `src/enhanced/errors.ts`).
+
+## Requester User ID
+
+In version 2.0.0, the requester user ID is passed as a method parameter (`xProximaNexusRequesterUserId` / `requesterUserId`) rather than in request bodies. This parameter is optional for most operations but required for operations that modify entities (create, update, delete) or when accessing non-public entities.
+
 ## Configuration
 
 The `ProximaNexusClientConfig` interface supports the following options:

package/dist/enhanced/enhanced-event-api.d.ts

@@ -0,0 +1,21 @@
+import type { EventApi } from '../api/event-api';
+import type { CreateEventDto, EntityConnectionDto, EventDto, UpdateEventDto, UserEntityConnectionDto } from '../models';
+export declare class EnhancedEventApi {
+    private readonly api;
+    constructor(api: EventApi);
+    getEvent(eventId: string, requesterUserId?: string): Promise<EventDto>;
+    getEvents(eventIds: string[], requesterUserId?: string): Promise<EventDto[]>;
+    createEvent(creatorUserId: string, data: CreateEventDto): Promise<string>;
+    updateEvent(eventId: string, requesterUserId: string, data: UpdateEventDto): Promise<string>;
+    deleteEvent(eventId: string, requesterUserId: string): Promise<void>;
+    searchByDisplayName(displayName: string, requesterUserId?: string, limit?: number): Promise<EventDto[]>;
+    searchByRadius(latitude: number, longitude: number, radiusMeters: number, requesterUserId?: string, limit?: number): Promise<EventDto[]>;
+    searchByBoundingBox(minLat: number, maxLat: number, minLng: number, maxLng: number, requesterUserId?: string, limit?: number): Promise<EventDto[]>;
+    addAttendee(eventId: string, userId: string, requesterUserId: string): Promise<EntityConnectionDto>;
+    removeAttendee(eventId: string, userId: string, requesterUserId: string): Promise<void>;
+    getAttendees(eventId: string, requesterUserId?: string): Promise<UserEntityConnectionDto[]>;
+    promoteToAdmin(eventId: string, userId: string, requesterUserId: string): Promise<EntityConnectionDto>;
+    demoteToAttendee(eventId: string, userId: string, requesterUserId: string): Promise<EntityConnectionDto>;
+    getAdmins(eventId: string, requesterUserId?: string): Promise<UserEntityConnectionDto[]>;
+    getOwner(eventId: string, requesterUserId?: string): Promise<UserEntityConnectionDto | undefined>;
+}

package/dist/enhanced/enhanced-event-api.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnhancedEventApi = void 0;
+const event_api_1 = require("../api/event-api");
+const mutate_event_entity_connection_dto_1 = require("../models/mutate-event-entity-connection-dto");
+const errors_1 = require("./errors");
+class EnhancedEventApi {
+    constructor(api) {
+        this.api = api;
+    }
+    async getEvent(eventId, requesterUserId) {
+        return (0, errors_1.unwrap)(this.api.get(eventId, requesterUserId));
+    }
+    async getEvents(eventIds, requesterUserId) {
+        return (0, errors_1.unwrap)(this.api.getBatch({ eventIds }, requesterUserId));
+    }
+    async createEvent(creatorUserId, data) {
+        return (0, errors_1.unwrap)(this.api.create(creatorUserId, data));
+    }
+    async updateEvent(eventId, requesterUserId, data) {
+        return (0, errors_1.unwrap)(this.api.update(eventId, requesterUserId, data));
+    }
+    async deleteEvent(eventId, requesterUserId) {
+        return (0, errors_1.unwrap)(this.api.remove(eventId, requesterUserId));
+    }
+    async searchByDisplayName(displayName, requesterUserId, limit) {
+        return (0, errors_1.unwrap)(this.api.search(displayName, undefined, undefined, undefined, undefined, undefined, undefined, undefined, limit, requesterUserId));
+    }
+    async searchByRadius(latitude, longitude, radiusMeters, requesterUserId, limit) {
+        return (0, errors_1.unwrap)(this.api.search(undefined, latitude, longitude, radiusMeters, undefined, undefined, undefined, undefined, limit, requesterUserId));
+    }
+    async searchByBoundingBox(minLat, maxLat, minLng, maxLng, requesterUserId, limit) {
+        return (0, errors_1.unwrap)(this.api.search(undefined, undefined, undefined, undefined, minLat, maxLat, minLng, maxLng, limit, requesterUserId));
+    }
+    async addAttendee(eventId, userId, requesterUserId) {
+        return (0, errors_1.unwrap)(this.api.addConnection(eventId, userId, requesterUserId, { type: mutate_event_entity_connection_dto_1.MutateEventEntityConnectionDtoTypeEnum.attendee }));
+    }
+    async removeAttendee(eventId, userId, requesterUserId) {
+        return (0, errors_1.unwrap)(this.api.removeConnection(eventId, userId, requesterUserId, { type: mutate_event_entity_connection_dto_1.MutateEventEntityConnectionDtoTypeEnum.attendee }));
+    }
+    async getAttendees(eventId, requesterUserId) {
+        return (0, errors_1.unwrap)(this.api.getConnections(eventId, [event_api_1.EventControllerGetConnectionsTypeEnum.attendee], requesterUserId));
+    }
+    async promoteToAdmin(eventId, userId, requesterUserId) {
+        return (0, errors_1.unwrap)(this.api.addConnection(eventId, userId, requesterUserId, { type: mutate_event_entity_connection_dto_1.MutateEventEntityConnectionDtoTypeEnum.admin }));
+    }
+    async demoteToAttendee(eventId, userId, requesterUserId) {
+        return (0, errors_1.unwrap)(this.api.addConnection(eventId, userId, requesterUserId, { type: mutate_event_entity_connection_dto_1.MutateEventEntityConnectionDtoTypeEnum.attendee }));
+    }
+    async getAdmins(eventId, requesterUserId) {
+        return (0, errors_1.unwrap)(this.api.getConnections(eventId, [event_api_1.EventControllerGetConnectionsTypeEnum.admin], requesterUserId));
+    }
+    async getOwner(eventId, requesterUserId) {
+        const connections = await (0, errors_1.unwrap)(this.api.getConnections(eventId, [event_api_1.EventControllerGetConnectionsTypeEnum.owner], requesterUserId));
+        return connections[0];
+    }
+}
+exports.EnhancedEventApi = EnhancedEventApi;

package/dist/enhanced/enhanced-group-api.d.ts

@@ -0,0 +1,26 @@
+import type { GroupApi } from '../api/group-api';
+import type { CreateGroupDto, EntityConnectionDto, EventEntityConnectionDto, GroupDto, UpdateGroupDto, UserEntityConnectionDto } from '../models';
+export declare class EnhancedGroupApi {
+    private readonly api;
+    constructor(api: GroupApi);
+    getGroup(groupId: string, requesterUserId?: string): Promise<GroupDto>;
+    getGroups(groupIds: string[], requesterUserId?: string): Promise<GroupDto[]>;
+    createGroup(creatorUserId: string, data: CreateGroupDto): Promise<string>;
+    updateGroup(groupId: string, requesterUserId: string, data: UpdateGroupDto): Promise<string>;
+    deleteGroup(groupId: string, requesterUserId: string): Promise<void>;
+    searchByDisplayName(displayName: string, requesterUserId?: string, limit?: number): Promise<GroupDto[]>;
+    searchByRadius(latitude: number, longitude: number, radiusMeters: number, requesterUserId?: string, limit?: number): Promise<GroupDto[]>;
+    searchByBoundingBox(minLat: number, maxLat: number, minLng: number, maxLng: number, requesterUserId?: string, limit?: number): Promise<GroupDto[]>;
+    joinGroup(groupId: string, userId: string): Promise<EntityConnectionDto>;
+    leaveGroup(groupId: string, userId: string): Promise<void>;
+    approveMember(groupId: string, userId: string, requesterUserId: string): Promise<EntityConnectionDto>;
+    rejectMember(groupId: string, userId: string, requesterUserId: string): Promise<void>;
+    removeMember(groupId: string, userId: string, requesterUserId: string): Promise<void>;
+    getMembers(groupId: string, requesterUserId?: string): Promise<UserEntityConnectionDto[]>;
+    getPendingMembers(groupId: string, requesterUserId?: string): Promise<UserEntityConnectionDto[]>;
+    promoteToAdmin(groupId: string, userId: string, requesterUserId: string): Promise<EntityConnectionDto>;
+    demoteToMember(groupId: string, userId: string, requesterUserId: string): Promise<EntityConnectionDto>;
+    getAdmins(groupId: string, requesterUserId?: string): Promise<UserEntityConnectionDto[]>;
+    getOwner(groupId: string, requesterUserId?: string): Promise<UserEntityConnectionDto | undefined>;
+    getEvents(groupId: string, requesterUserId?: string): Promise<EventEntityConnectionDto[]>;
+}

package/dist/enhanced/enhanced-group-api.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnhancedGroupApi = void 0;
+const group_api_1 = require("../api/group-api");
+const mutate_group_entity_connection_dto_1 = require("../models/mutate-group-entity-connection-dto");
+const errors_1 = require("./errors");
+class EnhancedGroupApi {
+    constructor(api) {
+        this.api = api;
+    }
+    async getGroup(groupId, requesterUserId) {
+        return (0, errors_1.unwrap)(this.api.get(groupId, requesterUserId));
+    }
+    async getGroups(groupIds, requesterUserId) {
+        return (0, errors_1.unwrap)(this.api.getBatch({ groupIds }, requesterUserId));
+    }
+    async createGroup(creatorUserId, data) {
+        return (0, errors_1.unwrap)(this.api.create(creatorUserId, data));
+    }
+    async updateGroup(groupId, requesterUserId, data) {
+        return (0, errors_1.unwrap)(this.api.update(groupId, requesterUserId, data));
+    }
+    async deleteGroup(groupId, requesterUserId) {
+        return (0, errors_1.unwrap)(this.api.remove(groupId, requesterUserId));
+    }
+    async searchByDisplayName(displayName, requesterUserId, limit) {
+        return (0, errors_1.unwrap)(this.api.search(displayName, undefined, undefined, undefined, undefined, undefined, undefined, undefined, limit, requesterUserId));
+    }
+    async searchByRadius(latitude, longitude, radiusMeters, requesterUserId, limit) {
+        return (0, errors_1.unwrap)(this.api.search(undefined, latitude, longitude, radiusMeters, undefined, undefined, undefined, undefined, limit, requesterUserId));
+    }
+    async searchByBoundingBox(minLat, maxLat, minLng, maxLng, requesterUserId, limit) {
+        return (0, errors_1.unwrap)(this.api.search(undefined, undefined, undefined, undefined, minLat, maxLat, minLng, maxLng, limit, requesterUserId));
+    }
+    async joinGroup(groupId, userId) {
+        return (0, errors_1.unwrap)(this.api.addConnection(groupId, userId, userId, { type: mutate_group_entity_connection_dto_1.MutateGroupEntityConnectionDtoTypeEnum.member }));
+    }
+    async leaveGroup(groupId, userId) {
+        return (0, errors_1.unwrap)(this.api.removeConnection(groupId, userId, userId, { type: mutate_group_entity_connection_dto_1.MutateGroupEntityConnectionDtoTypeEnum.member }));
+    }
+    async approveMember(groupId, userId, requesterUserId) {
+        return (0, errors_1.unwrap)(this.api.addConnection(groupId, userId, requesterUserId, { type: mutate_group_entity_connection_dto_1.MutateGroupEntityConnectionDtoTypeEnum.member }));
+    }
+    async rejectMember(groupId, userId, requesterUserId) {
+        return (0, errors_1.unwrap)(this.api.removeConnection(groupId, userId, requesterUserId, { type: mutate_group_entity_connection_dto_1.MutateGroupEntityConnectionDtoTypeEnum.member }));
+    }
+    async removeMember(groupId, userId, requesterUserId) {
+        return (0, errors_1.unwrap)(this.api.removeConnection(groupId, userId, requesterUserId, { type: mutate_group_entity_connection_dto_1.MutateGroupEntityConnectionDtoTypeEnum.member }));
+    }
+    async getMembers(groupId, requesterUserId) {
+        return (0, errors_1.unwrap)(this.api.getConnections(groupId, [group_api_1.GroupControllerGetConnectionsStateEnum.active], [group_api_1.GroupControllerGetConnectionsTypeEnum.member], requesterUserId));
+    }
+    async getPendingMembers(groupId, requesterUserId) {
+        return (0, errors_1.unwrap)(this.api.getConnections(groupId, [group_api_1.GroupControllerGetConnectionsStateEnum.requested], [group_api_1.GroupControllerGetConnectionsTypeEnum.member], requesterUserId));
+    }
+    async promoteToAdmin(groupId, userId, requesterUserId) {
+        return (0, errors_1.unwrap)(this.api.addConnection(groupId, userId, requesterUserId, { type: mutate_group_entity_connection_dto_1.MutateGroupEntityConnectionDtoTypeEnum.admin }));
+    }
+    async demoteToMember(groupId, userId, requesterUserId) {
+        return (0, errors_1.unwrap)(this.api.addConnection(groupId, userId, requesterUserId, { type: mutate_group_entity_connection_dto_1.MutateGroupEntityConnectionDtoTypeEnum.member }));
+    }
+    async getAdmins(groupId, requesterUserId) {
+        return (0, errors_1.unwrap)(this.api.getConnections(groupId, [group_api_1.GroupControllerGetConnectionsStateEnum.active], [group_api_1.GroupControllerGetConnectionsTypeEnum.admin], requesterUserId));
+    }
+    async getOwner(groupId, requesterUserId) {
+        const connections = await (0, errors_1.unwrap)(this.api.getConnections(groupId, [group_api_1.GroupControllerGetConnectionsStateEnum.active], [group_api_1.GroupControllerGetConnectionsTypeEnum.owner], requesterUserId));
+        return connections[0];
+    }
+    async getEvents(groupId, requesterUserId) {
+        return (0, errors_1.unwrap)(this.api.getEvents(groupId, requesterUserId));
+    }
+}
+exports.EnhancedGroupApi = EnhancedGroupApi;

package/dist/enhanced/enhanced-user-api.d.ts

@@ -0,0 +1,25 @@
+import type { UserApi } from '../api/user-api';
+import type { CreateUserDto, EntityConnectionDto, EventEntityConnectionDto, GroupEntityConnectionDto, MutateUserResponseDto, UpdateUserDto, UserDto, UserEntityConnectionDto } from '../models';
+export declare class EnhancedUserApi {
+    private readonly api;
+    constructor(api: UserApi);
+    getUser(userId: string, requesterUserId?: string): Promise<UserDto>;
+    getUsers(userIds: string[], requesterUserId?: string): Promise<UserDto[]>;
+    createUser(data: CreateUserDto): Promise<MutateUserResponseDto>;
+    updateUser(userId: string, data: UpdateUserDto, requesterUserId?: string): Promise<MutateUserResponseDto>;
+    deleteUser(userId: string, requesterUserId?: string): Promise<void>;
+    searchByDisplayName(displayName: string, requesterUserId?: string, limit?: number): Promise<UserDto[]>;
+    searchByRadius(latitude: number, longitude: number, radiusMeters: number, requesterUserId?: string, limit?: number): Promise<UserDto[]>;
+    searchByBoundingBox(minLat: number, maxLat: number, minLng: number, maxLng: number, requesterUserId?: string, limit?: number): Promise<UserDto[]>;
+    sendFriendRequest(fromUserId: string, toUserId: string): Promise<EntityConnectionDto>;
+    acceptFriendRequest(userId: string, fromUserId: string): Promise<EntityConnectionDto>;
+    declineFriendRequest(userId: string, fromUserId: string): Promise<void>;
+    removeFriend(userId: string, friendUserId: string): Promise<void>;
+    getFriends(userId: string, requesterUserId?: string): Promise<UserEntityConnectionDto[]>;
+    getPendingFriendRequests(userId: string): Promise<UserEntityConnectionDto[]>;
+    blockUser(blockingUserId: string, blockedUserId: string): Promise<EntityConnectionDto>;
+    unblockUser(blockingUserId: string, blockedUserId: string): Promise<void>;
+    getBlockedUsers(userId: string): Promise<UserEntityConnectionDto[]>;
+    getEvents(userId: string, requesterUserId?: string): Promise<EventEntityConnectionDto[]>;
+    getGroups(userId: string, requesterUserId?: string): Promise<GroupEntityConnectionDto[]>;
+}

package/dist/enhanced/enhanced-user-api.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnhancedUserApi = void 0;
+const user_api_1 = require("../api/user-api");
+const mutate_user_connection_dto_1 = require("../models/mutate-user-connection-dto");
+const errors_1 = require("./errors");
+class EnhancedUserApi {
+    constructor(api) {
+        this.api = api;
+    }
+    async getUser(userId, requesterUserId) {
+        return (0, errors_1.unwrap)(this.api.get(userId, requesterUserId));
+    }
+    async getUsers(userIds, requesterUserId) {
+        return (0, errors_1.unwrap)(this.api.getBatch({ userIds }, requesterUserId));
+    }
+    async createUser(data) {
+        return (0, errors_1.unwrap)(this.api.create(data));
+    }
+    async updateUser(userId, data, requesterUserId) {
+        const requester = requesterUserId ?? userId;
+        return (0, errors_1.unwrap)(this.api.update(userId, requester, data));
+    }
+    async deleteUser(userId, requesterUserId) {
+        const requester = requesterUserId ?? userId;
+        return (0, errors_1.unwrap)(this.api.remove(userId, requester));
+    }
+    async searchByDisplayName(displayName, requesterUserId, limit) {
+        return (0, errors_1.unwrap)(this.api.search(displayName, undefined, undefined, undefined, undefined, undefined, undefined, undefined, limit, requesterUserId));
+    }
+    async searchByRadius(latitude, longitude, radiusMeters, requesterUserId, limit) {
+        return (0, errors_1.unwrap)(this.api.search(undefined, latitude, longitude, radiusMeters, undefined, undefined, undefined, undefined, limit, requesterUserId));
+    }
+    async searchByBoundingBox(minLat, maxLat, minLng, maxLng, requesterUserId, limit) {
+        return (0, errors_1.unwrap)(this.api.search(undefined, undefined, undefined, undefined, minLat, maxLat, minLng, maxLng, limit, requesterUserId));
+    }
+    async sendFriendRequest(fromUserId, toUserId) {
+        return (0, errors_1.unwrap)(this.api.putConnection(fromUserId, toUserId, fromUserId, { type: mutate_user_connection_dto_1.MutateUserConnectionDtoTypeEnum.friend }));
+    }
+    async acceptFriendRequest(userId, fromUserId) {
+        return (0, errors_1.unwrap)(this.api.putConnection(userId, fromUserId, userId, { type: mutate_user_connection_dto_1.MutateUserConnectionDtoTypeEnum.friend }));
+    }
+    async declineFriendRequest(userId, fromUserId) {
+        return (0, errors_1.unwrap)(this.api.deleteConnection(userId, fromUserId, user_api_1.UserControllerDeleteConnectionTypeEnum.friend, userId));
+    }
+    async removeFriend(userId, friendUserId) {
+        return (0, errors_1.unwrap)(this.api.deleteConnection(userId, friendUserId, user_api_1.UserControllerDeleteConnectionTypeEnum.friend, userId));
+    }
+    async getFriends(userId, requesterUserId) {
+        return (0, errors_1.unwrap)(this.api.getConnections(userId, [user_api_1.UserControllerGetConnectionsStateEnum.active], [user_api_1.UserControllerGetConnectionsTypeEnum.friend], requesterUserId ?? userId));
+    }
+    async getPendingFriendRequests(userId) {
+        return (0, errors_1.unwrap)(this.api.getConnections(userId, [user_api_1.UserControllerGetConnectionsStateEnum.requested], [user_api_1.UserControllerGetConnectionsTypeEnum.friend], userId));
+    }
+    async blockUser(blockingUserId, blockedUserId) {
+        return (0, errors_1.unwrap)(this.api.putConnection(blockingUserId, blockedUserId, blockingUserId, { type: mutate_user_connection_dto_1.MutateUserConnectionDtoTypeEnum.blocked }));
+    }
+    async unblockUser(blockingUserId, blockedUserId) {
+        return (0, errors_1.unwrap)(this.api.deleteConnection(blockingUserId, blockedUserId, user_api_1.UserControllerDeleteConnectionTypeEnum.blocked, blockingUserId));
+    }
+    async getBlockedUsers(userId) {
+        return (0, errors_1.unwrap)(this.api.getConnections(userId, [user_api_1.UserControllerGetConnectionsStateEnum.blocked], [user_api_1.UserControllerGetConnectionsTypeEnum.blocked], userId));
+    }
+    async getEvents(userId, requesterUserId) {
+        return (0, errors_1.unwrap)(this.api.getEvents(userId, requesterUserId));
+    }
+    async getGroups(userId, requesterUserId) {
+        return (0, errors_1.unwrap)(this.api.getGroups(userId, requesterUserId));
+    }
+}
+exports.EnhancedUserApi = EnhancedUserApi;

package/dist/enhanced/errors.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Custom error classes for the enhanced SDK client.
+ * Axios errors are transformed into these domain-specific errors.
+ */
+/**
+ * Base class for enhanced client errors.
+ */
+export declare class EnhancedClientError extends Error {
+    readonly statusCode?: number | undefined;
+    readonly cause?: unknown | undefined;
+    constructor(message: string, statusCode?: number | undefined, cause?: unknown | undefined);
+}
+/**
+ * Thrown when an entity is not found (HTTP 404).
+ */
+export declare class NotFoundError extends EnhancedClientError {
+    constructor(message?: string, statusCode?: number, cause?: unknown);
+}
+/**
+ * Thrown when the user lacks permission (HTTP 401 or 403).
+ */
+export declare class UnauthorizedError extends EnhancedClientError {
+    constructor(message?: string, statusCode?: number, cause?: unknown);
+}
+/**
+ * Thrown for invalid parameters or validation failures (HTTP 400 or 422).
+ */
+export declare class ValidationError extends EnhancedClientError {
+    constructor(message?: string, statusCode?: number, cause?: unknown);
+}
+/**
+ * Transforms an axios error into an enhanced client error.
+ */
+export declare function transformAxiosError(error: unknown): never;
+/**
+ * Unwraps an axios response and transforms errors.
+ */
+export declare function unwrap<T>(promise: Promise<{
+    data: T;
+}>): Promise<T>;

package/dist/enhanced/errors.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * Custom error classes for the enhanced SDK client.
+ * Axios errors are transformed into these domain-specific errors.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationError = exports.UnauthorizedError = exports.NotFoundError = exports.EnhancedClientError = void 0;
+exports.transformAxiosError = transformAxiosError;
+exports.unwrap = unwrap;
+/**
+ * Base class for enhanced client errors.
+ */
+class EnhancedClientError extends Error {
+    constructor(message, statusCode, cause) {
+        super(message);
+        this.statusCode = statusCode;
+        this.cause = cause;
+        this.name = this.constructor.name;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.EnhancedClientError = EnhancedClientError;
+/**
+ * Thrown when an entity is not found (HTTP 404).
+ */
+class NotFoundError extends EnhancedClientError {
+    constructor(message = 'Resource not found', statusCode = 404, cause) {
+        super(message, statusCode, cause);
+    }
+}
+exports.NotFoundError = NotFoundError;
+/**
+ * Thrown when the user lacks permission (HTTP 401 or 403).
+ */
+class UnauthorizedError extends EnhancedClientError {
+    constructor(message = 'Unauthorized', statusCode = 401, cause) {
+        super(message, statusCode, cause);
+    }
+}
+exports.UnauthorizedError = UnauthorizedError;
+/**
+ * Thrown for invalid parameters or validation failures (HTTP 400 or 422).
+ */
+class ValidationError extends EnhancedClientError {
+    constructor(message = 'Validation failed', statusCode, cause) {
+        super(message, statusCode, cause);
+    }
+}
+exports.ValidationError = ValidationError;
+/**
+ * Transforms an axios error into an enhanced client error.
+ */
+function transformAxiosError(error) {
+    if (error && typeof error === 'object' && 'isAxiosError' in error) {
+        const axiosError = error;
+        const status = axiosError.response?.status;
+        const message = typeof axiosError.response?.data === 'object' &&
+            axiosError.response?.data !== null &&
+            'message' in axiosError.response.data
+            ? String(axiosError.response.data.message)
+            : axiosError.message ?? 'Request failed';
+        if (status === 404) {
+            throw new NotFoundError(message, status, error);
+        }
+        if (status === 401 || status === 403) {
+            throw new UnauthorizedError(message, status ?? 401, error);
+        }
+        if (status === 400 || status === 422) {
+            throw new ValidationError(message, status, error);
+        }
+        throw new EnhancedClientError(message, status, error);
+    }
+    throw error;
+}
+/**
+ * Unwraps an axios response and transforms errors.
+ */
+async function unwrap(promise) {
+    try {
+        const response = await promise;
+        return response.data;
+    }
+    catch (error) {
+        transformAxiosError(error);
+        return undefined;
+    }
+}

package/dist/enhanced/index.d.ts

@@ -0,0 +1,34 @@
+import { EnhancedUserApi } from './enhanced-user-api';
+import { EnhancedEventApi } from './enhanced-event-api';
+import { EnhancedGroupApi } from './enhanced-group-api';
+/**
+ * Configuration for the enhanced client (same shape as ProximaNexusClientConfig).
+ * Defined here to avoid circular dependency with main index.
+ */
+export interface EnhancedClientConfig {
+    baseURL?: string;
+    apiKey: string;
+    timeout?: number;
+    axiosConfig?: any;
+}
+export { EnhancedUserApi } from './enhanced-user-api';
+export { EnhancedEventApi } from './enhanced-event-api';
+export { EnhancedGroupApi } from './enhanced-group-api';
+export { NotFoundError, UnauthorizedError, ValidationError, EnhancedClientError, transformAxiosError, unwrap, } from './errors';
+export type { EnhancedClientError as EnhancedClientErrorType } from './errors';
+export * from './types';
+/**
+ * Enhanced Proxima Nexus client with a simplified, domain-driven API.
+ * Wraps the base APIs and provides cleaner method signatures and convenience methods.
+ * Use `client.base` to access the raw APIs when needed.
+ *
+ * Accepts either EnhancedClientConfig or a ProximaNexusClient instance for base.
+ */
+export declare class EnhancedProximaNexusClient {
+    readonly users: EnhancedUserApi;
+    readonly events: EnhancedEventApi;
+    readonly groups: EnhancedGroupApi;
+    readonly base: InstanceType<typeof import('../index').ProximaNexusClient>;
+    constructor(configOrBase: EnhancedClientConfig | InstanceType<typeof import('../index').ProximaNexusClient>);
+}
+export default EnhancedProximaNexusClient;

package/dist/enhanced/index.js

@@ -0,0 +1,64 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnhancedProximaNexusClient = exports.unwrap = exports.transformAxiosError = exports.EnhancedClientError = exports.ValidationError = exports.UnauthorizedError = exports.NotFoundError = exports.EnhancedGroupApi = exports.EnhancedEventApi = exports.EnhancedUserApi = void 0;
+const enhanced_user_api_1 = require("./enhanced-user-api");
+const enhanced_event_api_1 = require("./enhanced-event-api");
+const enhanced_group_api_1 = require("./enhanced-group-api");
+var enhanced_user_api_2 = require("./enhanced-user-api");
+Object.defineProperty(exports, "EnhancedUserApi", { enumerable: true, get: function () { return enhanced_user_api_2.EnhancedUserApi; } });
+var enhanced_event_api_2 = require("./enhanced-event-api");
+Object.defineProperty(exports, "EnhancedEventApi", { enumerable: true, get: function () { return enhanced_event_api_2.EnhancedEventApi; } });
+var enhanced_group_api_2 = require("./enhanced-group-api");
+Object.defineProperty(exports, "EnhancedGroupApi", { enumerable: true, get: function () { return enhanced_group_api_2.EnhancedGroupApi; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "NotFoundError", { enumerable: true, get: function () { return errors_1.NotFoundError; } });
+Object.defineProperty(exports, "UnauthorizedError", { enumerable: true, get: function () { return errors_1.UnauthorizedError; } });
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return errors_1.ValidationError; } });
+Object.defineProperty(exports, "EnhancedClientError", { enumerable: true, get: function () { return errors_1.EnhancedClientError; } });
+Object.defineProperty(exports, "transformAxiosError", { enumerable: true, get: function () { return errors_1.transformAxiosError; } });
+Object.defineProperty(exports, "unwrap", { enumerable: true, get: function () { return errors_1.unwrap; } });
+__exportStar(require("./types"), exports);
+/**
+ * Enhanced Proxima Nexus client with a simplified, domain-driven API.
+ * Wraps the base APIs and provides cleaner method signatures and convenience methods.
+ * Use `client.base` to access the raw APIs when needed.
+ *
+ * Accepts either EnhancedClientConfig or a ProximaNexusClient instance for base.
+ */
+class EnhancedProximaNexusClient {
+    constructor(configOrBase) {
+        const isConfig = typeof configOrBase.apiKey === 'string';
+        if (isConfig) {
+            const config = configOrBase;
+            // Dynamic import to break cycle: main index will export EnhancedProximaNexusClient
+            // and we need ProximaNexusClient here. We construct base client from same config.
+            const { ProximaNexusClient } = require('../index');
+            this.base = new ProximaNexusClient(config);
+        }
+        else {
+            this.base = configOrBase;
+        }
+        const userApi = this.base.users;
+        const eventApi = this.base.events;
+        const groupApi = this.base.groups;
+        this.users = new enhanced_user_api_1.EnhancedUserApi(userApi);
+        this.events = new enhanced_event_api_1.EnhancedEventApi(eventApi);
+        this.groups = new enhanced_group_api_1.EnhancedGroupApi(groupApi);
+    }
+}
+exports.EnhancedProximaNexusClient = EnhancedProximaNexusClient;
+exports.default = EnhancedProximaNexusClient;

package/dist/enhanced/types.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Shared types and interfaces for the enhanced SDK client.
+ * Re-exports model types for convenience; no additional interfaces needed
+ * as we use the existing DTOs from the base API.
+ */
+export type { CreateUserDto, UpdateUserDto, MutateUserResponseDto, CreateEventDto, UpdateEventDto, CreateGroupDto, UpdateGroupDto, UserDto, EventDto, GroupDto, EntityConnectionDto, UserEntityConnectionDto, EventEntityConnectionDto, GroupEntityConnectionDto, GetUsersDto, GetEventsDto, GetGroupsDto, } from '../models';

package/dist/enhanced/types.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * Shared types and interfaces for the enhanced SDK client.
+ * Re-exports model types for convenience; no additional interfaces needed
+ * as we use the existing DTOs from the base API.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -36,3 +36,5 @@ export declare class ProximaNexusClient {
     constructor(config: ProximaNexusClientConfig);
 }
 export default ProximaNexusClient;
+export { EnhancedProximaNexusClient, EnhancedUserApi, EnhancedEventApi, EnhancedGroupApi, NotFoundError, UnauthorizedError, ValidationError, EnhancedClientError, transformAxiosError, unwrap, type EnhancedClientConfig, } from './enhanced';
+export type { EnhancedClientError as EnhancedClientErrorType } from './enhanced';

package/dist/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProximaNexusClient = exports.Configuration = exports.GroupApi = exports.EventApi = exports.UserApi = void 0;
+exports.unwrap = exports.transformAxiosError = exports.EnhancedClientError = exports.ValidationError = exports.UnauthorizedError = exports.NotFoundError = exports.EnhancedGroupApi = exports.EnhancedEventApi = exports.EnhancedUserApi = exports.EnhancedProximaNexusClient = exports.ProximaNexusClient = exports.Configuration = exports.GroupApi = exports.EventApi = exports.UserApi = void 0;
 const configuration_1 = require("./configuration");
 Object.defineProperty(exports, "Configuration", { enumerable: true, get: function () { return configuration_1.Configuration; } });
 const user_api_1 = require("./api/user-api");
@@ -42,3 +42,15 @@ class ProximaNexusClient {
 }
 exports.ProximaNexusClient = ProximaNexusClient;
 exports.default = ProximaNexusClient;
+// Enhanced client (separate export path to avoid circular dependency in enhanced module)
+var enhanced_1 = require("./enhanced");
+Object.defineProperty(exports, "EnhancedProximaNexusClient", { enumerable: true, get: function () { return enhanced_1.EnhancedProximaNexusClient; } });
+Object.defineProperty(exports, "EnhancedUserApi", { enumerable: true, get: function () { return enhanced_1.EnhancedUserApi; } });
+Object.defineProperty(exports, "EnhancedEventApi", { enumerable: true, get: function () { return enhanced_1.EnhancedEventApi; } });
+Object.defineProperty(exports, "EnhancedGroupApi", { enumerable: true, get: function () { return enhanced_1.EnhancedGroupApi; } });
+Object.defineProperty(exports, "NotFoundError", { enumerable: true, get: function () { return enhanced_1.NotFoundError; } });
+Object.defineProperty(exports, "UnauthorizedError", { enumerable: true, get: function () { return enhanced_1.UnauthorizedError; } });
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return enhanced_1.ValidationError; } });
+Object.defineProperty(exports, "EnhancedClientError", { enumerable: true, get: function () { return enhanced_1.EnhancedClientError; } });
+Object.defineProperty(exports, "transformAxiosError", { enumerable: true, get: function () { return enhanced_1.transformAxiosError; } });
+Object.defineProperty(exports, "unwrap", { enumerable: true, get: function () { return enhanced_1.unwrap; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proxima-nexus/sdk-typescript",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "TypeScript SDK for Proxima Nexus Data Plane API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",