@proxima-nexus/sdk-typescript 2.0.1 → 2.1.1

package/CHANGELOG.md

@@ -5,6 +5,37 @@ 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.1] - 2026-02-04
+
+### Changed
+
+- Updated `@proxima-nexus/openapi` to `^2.0.1` and regenerated connection DTOs to match the latest API schema for connection states (including `incoming_request`, `outgoing_request`, and `invited`).
+- Made `state` optional on connection DTOs and cleaned up enum values to better reflect the underlying API.
+- Updated `UserApi` and `GroupApi` connection state enums to use the new state names.
+- Adjusted enhanced client helpers so that:
+  - `getPendingFriendRequests` returns both incoming and outgoing friend requests using the new state values.
+  - `getBlockedUsers` filters on connection type `blocked` while keeping state `active`.
+  - `getMembers` for groups returns active members, admins, and the owner.
+
+## [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

package/README.md

@@ -2,29 +2,57 @@
 
 TypeScript SDK for the Proxima Nexus Data Plane API.
 
-> **Note:** This SDK version 2.0.0 includes breaking changes. See the [CHANGELOG.md](./CHANGELOG.md) for migration details.
-
 ## 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() {
@@ -124,7 +152,7 @@ async function main() {
 }
 ```
 
-### Event Operations
+### Event Operations (Base Client)
 
 ```typescript
 async function main() {
@@ -219,7 +247,7 @@ async function main() {
 }
 ```
 
-### Group Operations
+### Group Operations (Base Client)
 
 ```typescript
 async function main() {
@@ -310,9 +338,21 @@ 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`) 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.
+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
 

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

@@ -573,8 +573,7 @@ export declare class GroupApi extends BaseAPI implements GroupApiInterface {
 export declare enum GroupControllerGetConnectionsStateEnum {
     requested = "requested",
     active = "active",
-    rejected = "rejected",
-    blocked = "blocked"
+    invited = "invited"
 }
 export declare enum GroupControllerGetConnectionsTypeEnum {
     member = "member",

package/dist/api/group-api.js

@@ -897,8 +897,7 @@ var GroupControllerGetConnectionsStateEnum;
 (function (GroupControllerGetConnectionsStateEnum) {
     GroupControllerGetConnectionsStateEnum["requested"] = "requested";
     GroupControllerGetConnectionsStateEnum["active"] = "active";
-    GroupControllerGetConnectionsStateEnum["rejected"] = "rejected";
-    GroupControllerGetConnectionsStateEnum["blocked"] = "blocked";
+    GroupControllerGetConnectionsStateEnum["invited"] = "invited";
 })(GroupControllerGetConnectionsStateEnum || (exports.GroupControllerGetConnectionsStateEnum = GroupControllerGetConnectionsStateEnum = {}));
 var GroupControllerGetConnectionsTypeEnum;
 (function (GroupControllerGetConnectionsTypeEnum) {

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

@@ -617,10 +617,9 @@ export declare enum UserControllerDeleteConnectionTypeEnum {
     blocked = "blocked"
 }
 export declare enum UserControllerGetConnectionsStateEnum {
-    requested = "requested",
-    active = "active",
-    rejected = "rejected",
-    blocked = "blocked"
+    incoming_request = "incoming_request",
+    outgoing_request = "outgoing_request",
+    active = "active"
 }
 export declare enum UserControllerGetConnectionsTypeEnum {
     friend = "friend",

package/dist/api/user-api.js

@@ -964,10 +964,9 @@ var UserControllerDeleteConnectionTypeEnum;
 })(UserControllerDeleteConnectionTypeEnum || (exports.UserControllerDeleteConnectionTypeEnum = UserControllerDeleteConnectionTypeEnum = {}));
 var UserControllerGetConnectionsStateEnum;
 (function (UserControllerGetConnectionsStateEnum) {
-    UserControllerGetConnectionsStateEnum["requested"] = "requested";
+    UserControllerGetConnectionsStateEnum["incoming_request"] = "incoming_request";
+    UserControllerGetConnectionsStateEnum["outgoing_request"] = "outgoing_request";
     UserControllerGetConnectionsStateEnum["active"] = "active";
-    UserControllerGetConnectionsStateEnum["rejected"] = "rejected";
-    UserControllerGetConnectionsStateEnum["blocked"] = "blocked";
 })(UserControllerGetConnectionsStateEnum || (exports.UserControllerGetConnectionsStateEnum = UserControllerGetConnectionsStateEnum = {}));
 var UserControllerGetConnectionsTypeEnum;
 (function (UserControllerGetConnectionsTypeEnum) {

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,77 @@
+"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,
+            group_api_1.GroupControllerGetConnectionsTypeEnum.admin,
+            group_api_1.GroupControllerGetConnectionsTypeEnum.owner,
+        ], 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,74 @@
+"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.outgoing_request,
+            user_api_1.UserControllerGetConnectionsStateEnum.incoming_request,
+        ], [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.active], [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/dist/models/entity-connection-dto.d.ts

@@ -18,29 +18,28 @@ export interface EntityConnectionDto {
      * Date/time the connection was last updated (ISO string)
      */
     'updatedAt'?: string;
-    /**
-     * Connection state
-     */
-    'state': EntityConnectionDtoStateEnum;
     /**
      * Connection type
      */
     'type': EntityConnectionDtoTypeEnum;
-}
-export declare enum EntityConnectionDtoStateEnum {
-    requested = "requested",
-    active = "active",
-    rejected = "rejected",
-    blocked = "blocked"
+    /**
+     * Connection state
+     */
+    'state'?: EntityConnectionDtoStateEnum;
 }
 export declare enum EntityConnectionDtoTypeEnum {
     attendee = "attendee",
     admin = "admin",
     owner = "owner",
     member = "member",
-    admin2 = "admin",
-    owner2 = "owner",
     friend = "friend",
     blocked = "blocked",
     none = "none"
 }
+export declare enum EntityConnectionDtoStateEnum {
+    incoming_request = "incoming_request",
+    outgoing_request = "outgoing_request",
+    active = "active",
+    requested = "requested",
+    invited = "invited"
+}

package/dist/models/entity-connection-dto.js

@@ -13,23 +13,22 @@
  * Do not edit the class manually.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityConnectionDtoTypeEnum = exports.EntityConnectionDtoStateEnum = void 0;
-var EntityConnectionDtoStateEnum;
-(function (EntityConnectionDtoStateEnum) {
-    EntityConnectionDtoStateEnum["requested"] = "requested";
-    EntityConnectionDtoStateEnum["active"] = "active";
-    EntityConnectionDtoStateEnum["rejected"] = "rejected";
-    EntityConnectionDtoStateEnum["blocked"] = "blocked";
-})(EntityConnectionDtoStateEnum || (exports.EntityConnectionDtoStateEnum = EntityConnectionDtoStateEnum = {}));
+exports.EntityConnectionDtoStateEnum = exports.EntityConnectionDtoTypeEnum = void 0;
 var EntityConnectionDtoTypeEnum;
 (function (EntityConnectionDtoTypeEnum) {
     EntityConnectionDtoTypeEnum["attendee"] = "attendee";
     EntityConnectionDtoTypeEnum["admin"] = "admin";
     EntityConnectionDtoTypeEnum["owner"] = "owner";
     EntityConnectionDtoTypeEnum["member"] = "member";
-    EntityConnectionDtoTypeEnum["admin2"] = "admin";
-    EntityConnectionDtoTypeEnum["owner2"] = "owner";
     EntityConnectionDtoTypeEnum["friend"] = "friend";
     EntityConnectionDtoTypeEnum["blocked"] = "blocked";
     EntityConnectionDtoTypeEnum["none"] = "none";
 })(EntityConnectionDtoTypeEnum || (exports.EntityConnectionDtoTypeEnum = EntityConnectionDtoTypeEnum = {}));
+var EntityConnectionDtoStateEnum;
+(function (EntityConnectionDtoStateEnum) {
+    EntityConnectionDtoStateEnum["incoming_request"] = "incoming_request";
+    EntityConnectionDtoStateEnum["outgoing_request"] = "outgoing_request";
+    EntityConnectionDtoStateEnum["active"] = "active";
+    EntityConnectionDtoStateEnum["requested"] = "requested";
+    EntityConnectionDtoStateEnum["invited"] = "invited";
+})(EntityConnectionDtoStateEnum || (exports.EntityConnectionDtoStateEnum = EntityConnectionDtoStateEnum = {}));

package/dist/models/event-entity-connection-dto.d.ts

@@ -18,33 +18,32 @@ export interface EventEntityConnectionDto {
      * Date/time the connection was last updated (ISO string)
      */
     'updatedAt'?: string;
-    /**
-     * Connection state
-     */
-    'state': EventEntityConnectionDtoStateEnum;
     /**
      * Connection type
      */
     'type': EventEntityConnectionDtoTypeEnum;
+    /**
+     * Connection state
+     */
+    'state'?: EventEntityConnectionDtoStateEnum;
     /**
      * Event ID
      */
     'eventId': string;
 }
-export declare enum EventEntityConnectionDtoStateEnum {
-    requested = "requested",
-    active = "active",
-    rejected = "rejected",
-    blocked = "blocked"
-}
 export declare enum EventEntityConnectionDtoTypeEnum {
     attendee = "attendee",
     admin = "admin",
     owner = "owner",
     member = "member",
-    admin2 = "admin",
-    owner2 = "owner",
     friend = "friend",
     blocked = "blocked",
     none = "none"
 }
+export declare enum EventEntityConnectionDtoStateEnum {
+    incoming_request = "incoming_request",
+    outgoing_request = "outgoing_request",
+    active = "active",
+    requested = "requested",
+    invited = "invited"
+}

package/dist/models/event-entity-connection-dto.js

@@ -13,23 +13,22 @@
  * Do not edit the class manually.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventEntityConnectionDtoTypeEnum = exports.EventEntityConnectionDtoStateEnum = void 0;
-var EventEntityConnectionDtoStateEnum;
-(function (EventEntityConnectionDtoStateEnum) {
-    EventEntityConnectionDtoStateEnum["requested"] = "requested";
-    EventEntityConnectionDtoStateEnum["active"] = "active";
-    EventEntityConnectionDtoStateEnum["rejected"] = "rejected";
-    EventEntityConnectionDtoStateEnum["blocked"] = "blocked";
-})(EventEntityConnectionDtoStateEnum || (exports.EventEntityConnectionDtoStateEnum = EventEntityConnectionDtoStateEnum = {}));
+exports.EventEntityConnectionDtoStateEnum = exports.EventEntityConnectionDtoTypeEnum = void 0;
 var EventEntityConnectionDtoTypeEnum;
 (function (EventEntityConnectionDtoTypeEnum) {
     EventEntityConnectionDtoTypeEnum["attendee"] = "attendee";
     EventEntityConnectionDtoTypeEnum["admin"] = "admin";
     EventEntityConnectionDtoTypeEnum["owner"] = "owner";
     EventEntityConnectionDtoTypeEnum["member"] = "member";
-    EventEntityConnectionDtoTypeEnum["admin2"] = "admin";
-    EventEntityConnectionDtoTypeEnum["owner2"] = "owner";
     EventEntityConnectionDtoTypeEnum["friend"] = "friend";
     EventEntityConnectionDtoTypeEnum["blocked"] = "blocked";
     EventEntityConnectionDtoTypeEnum["none"] = "none";
 })(EventEntityConnectionDtoTypeEnum || (exports.EventEntityConnectionDtoTypeEnum = EventEntityConnectionDtoTypeEnum = {}));
+var EventEntityConnectionDtoStateEnum;
+(function (EventEntityConnectionDtoStateEnum) {
+    EventEntityConnectionDtoStateEnum["incoming_request"] = "incoming_request";
+    EventEntityConnectionDtoStateEnum["outgoing_request"] = "outgoing_request";
+    EventEntityConnectionDtoStateEnum["active"] = "active";
+    EventEntityConnectionDtoStateEnum["requested"] = "requested";
+    EventEntityConnectionDtoStateEnum["invited"] = "invited";
+})(EventEntityConnectionDtoStateEnum || (exports.EventEntityConnectionDtoStateEnum = EventEntityConnectionDtoStateEnum = {}));

package/dist/models/group-entity-connection-dto.d.ts

@@ -18,33 +18,32 @@ export interface GroupEntityConnectionDto {
      * Date/time the connection was last updated (ISO string)
      */
     'updatedAt'?: string;
-    /**
-     * Connection state
-     */
-    'state': GroupEntityConnectionDtoStateEnum;
     /**
      * Connection type
      */
     'type': GroupEntityConnectionDtoTypeEnum;
+    /**
+     * Connection state
+     */
+    'state'?: GroupEntityConnectionDtoStateEnum;
     /**
      * Group ID
      */
     'groupId': string;
 }
-export declare enum GroupEntityConnectionDtoStateEnum {
-    requested = "requested",
-    active = "active",
-    rejected = "rejected",
-    blocked = "blocked"
-}
 export declare enum GroupEntityConnectionDtoTypeEnum {
     attendee = "attendee",
     admin = "admin",
     owner = "owner",
     member = "member",
-    admin2 = "admin",
-    owner2 = "owner",
     friend = "friend",
     blocked = "blocked",
     none = "none"
 }
+export declare enum GroupEntityConnectionDtoStateEnum {
+    incoming_request = "incoming_request",
+    outgoing_request = "outgoing_request",
+    active = "active",
+    requested = "requested",
+    invited = "invited"
+}

package/dist/models/group-entity-connection-dto.js

@@ -13,23 +13,22 @@
  * Do not edit the class manually.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GroupEntityConnectionDtoTypeEnum = exports.GroupEntityConnectionDtoStateEnum = void 0;
-var GroupEntityConnectionDtoStateEnum;
-(function (GroupEntityConnectionDtoStateEnum) {
-    GroupEntityConnectionDtoStateEnum["requested"] = "requested";
-    GroupEntityConnectionDtoStateEnum["active"] = "active";
-    GroupEntityConnectionDtoStateEnum["rejected"] = "rejected";
-    GroupEntityConnectionDtoStateEnum["blocked"] = "blocked";
-})(GroupEntityConnectionDtoStateEnum || (exports.GroupEntityConnectionDtoStateEnum = GroupEntityConnectionDtoStateEnum = {}));
+exports.GroupEntityConnectionDtoStateEnum = exports.GroupEntityConnectionDtoTypeEnum = void 0;
 var GroupEntityConnectionDtoTypeEnum;
 (function (GroupEntityConnectionDtoTypeEnum) {
     GroupEntityConnectionDtoTypeEnum["attendee"] = "attendee";
     GroupEntityConnectionDtoTypeEnum["admin"] = "admin";
     GroupEntityConnectionDtoTypeEnum["owner"] = "owner";
     GroupEntityConnectionDtoTypeEnum["member"] = "member";
-    GroupEntityConnectionDtoTypeEnum["admin2"] = "admin";
-    GroupEntityConnectionDtoTypeEnum["owner2"] = "owner";
     GroupEntityConnectionDtoTypeEnum["friend"] = "friend";
     GroupEntityConnectionDtoTypeEnum["blocked"] = "blocked";
     GroupEntityConnectionDtoTypeEnum["none"] = "none";
 })(GroupEntityConnectionDtoTypeEnum || (exports.GroupEntityConnectionDtoTypeEnum = GroupEntityConnectionDtoTypeEnum = {}));
+var GroupEntityConnectionDtoStateEnum;
+(function (GroupEntityConnectionDtoStateEnum) {
+    GroupEntityConnectionDtoStateEnum["incoming_request"] = "incoming_request";
+    GroupEntityConnectionDtoStateEnum["outgoing_request"] = "outgoing_request";
+    GroupEntityConnectionDtoStateEnum["active"] = "active";
+    GroupEntityConnectionDtoStateEnum["requested"] = "requested";
+    GroupEntityConnectionDtoStateEnum["invited"] = "invited";
+})(GroupEntityConnectionDtoStateEnum || (exports.GroupEntityConnectionDtoStateEnum = GroupEntityConnectionDtoStateEnum = {}));

package/dist/models/user-entity-connection-dto.d.ts

@@ -18,33 +18,32 @@ export interface UserEntityConnectionDto {
      * Date/time the connection was last updated (ISO string)
      */
     'updatedAt'?: string;
-    /**
-     * Connection state
-     */
-    'state': UserEntityConnectionDtoStateEnum;
     /**
      * Connection type
      */
     'type': UserEntityConnectionDtoTypeEnum;
+    /**
+     * Connection state
+     */
+    'state'?: UserEntityConnectionDtoStateEnum;
     /**
      * User ID
      */
     'userId': string;
 }
-export declare enum UserEntityConnectionDtoStateEnum {
-    requested = "requested",
-    active = "active",
-    rejected = "rejected",
-    blocked = "blocked"
-}
 export declare enum UserEntityConnectionDtoTypeEnum {
     attendee = "attendee",
     admin = "admin",
     owner = "owner",
     member = "member",
-    admin2 = "admin",
-    owner2 = "owner",
     friend = "friend",
     blocked = "blocked",
     none = "none"
 }
+export declare enum UserEntityConnectionDtoStateEnum {
+    incoming_request = "incoming_request",
+    outgoing_request = "outgoing_request",
+    active = "active",
+    requested = "requested",
+    invited = "invited"
+}

package/dist/models/user-entity-connection-dto.js

@@ -13,23 +13,22 @@
  * Do not edit the class manually.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UserEntityConnectionDtoTypeEnum = exports.UserEntityConnectionDtoStateEnum = void 0;
-var UserEntityConnectionDtoStateEnum;
-(function (UserEntityConnectionDtoStateEnum) {
-    UserEntityConnectionDtoStateEnum["requested"] = "requested";
-    UserEntityConnectionDtoStateEnum["active"] = "active";
-    UserEntityConnectionDtoStateEnum["rejected"] = "rejected";
-    UserEntityConnectionDtoStateEnum["blocked"] = "blocked";
-})(UserEntityConnectionDtoStateEnum || (exports.UserEntityConnectionDtoStateEnum = UserEntityConnectionDtoStateEnum = {}));
+exports.UserEntityConnectionDtoStateEnum = exports.UserEntityConnectionDtoTypeEnum = void 0;
 var UserEntityConnectionDtoTypeEnum;
 (function (UserEntityConnectionDtoTypeEnum) {
     UserEntityConnectionDtoTypeEnum["attendee"] = "attendee";
     UserEntityConnectionDtoTypeEnum["admin"] = "admin";
     UserEntityConnectionDtoTypeEnum["owner"] = "owner";
     UserEntityConnectionDtoTypeEnum["member"] = "member";
-    UserEntityConnectionDtoTypeEnum["admin2"] = "admin";
-    UserEntityConnectionDtoTypeEnum["owner2"] = "owner";
     UserEntityConnectionDtoTypeEnum["friend"] = "friend";
     UserEntityConnectionDtoTypeEnum["blocked"] = "blocked";
     UserEntityConnectionDtoTypeEnum["none"] = "none";
 })(UserEntityConnectionDtoTypeEnum || (exports.UserEntityConnectionDtoTypeEnum = UserEntityConnectionDtoTypeEnum = {}));
+var UserEntityConnectionDtoStateEnum;
+(function (UserEntityConnectionDtoStateEnum) {
+    UserEntityConnectionDtoStateEnum["incoming_request"] = "incoming_request";
+    UserEntityConnectionDtoStateEnum["outgoing_request"] = "outgoing_request";
+    UserEntityConnectionDtoStateEnum["active"] = "active";
+    UserEntityConnectionDtoStateEnum["requested"] = "requested";
+    UserEntityConnectionDtoStateEnum["invited"] = "invited";
+})(UserEntityConnectionDtoStateEnum || (exports.UserEntityConnectionDtoStateEnum = UserEntityConnectionDtoStateEnum = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proxima-nexus/sdk-typescript",
-  "version": "2.0.1",
+  "version": "2.1.1",
   "description": "TypeScript SDK for Proxima Nexus Data Plane API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -43,7 +43,7 @@
   },
   "devDependencies": {
     "@openapitools/openapi-generator-cli": "^2.7.0",
-    "@proxima-nexus/openapi": "^2.0.0",
+    "@proxima-nexus/openapi": "^2.0.1",
     "@types/node": "^20.10.0",
     "typescript": "^5.3.3",
     "ts-node": "^10.9.2"