@athos-sdk/api-types 1.0.0 → 2.0.0

package/dist/index.d.mts

@@ -416,4 +416,427 @@ interface Activity {
     createdAt: string;
 }
 
-export { type Activity, type AddExpertDto, type AddMemberDto, type AddStaffDto, type AdminSummaryResponse, type AuthResponse, type AvailabilitySlotDto, type Booking, BookingStatus, type Challenge, type ChallengeOccurrence, type ChallengeOccurrenceWithDetails, type ChallengeParticipation, ChallengeVerificationType, type CheckIn, type CompleteChallengeDto, type CreateBookingDto, type CreateChallengeDto, type CreateCheckInDto, type CreateLeaderboardDto, type CreateOccurrenceDto, type CreateRewardDto, type Expert, type ExpertAvailability, type ExpertAvailabilityException, type ExpertAvailabilityResponse, ExpertRole, type ExpertWithUser, type GetMeResponse, type Gym, type JoinChallengeDto, type JoinGymDto, type Leaderboard, type LeaderboardEntry, LeaderboardEntryStatus, type LeaderboardWithEntries, type Level, type LoginDto, type Media, type Member, type MemberReward, type MemberStatsResponse, type MemberWithGym, type MemberWithUser, type Notification, type RegisterDto, type RegisterResponse, type ReviewEntryDto, type Reward, type SetAvailabilityDto, type SetAvailabilityExceptionDto, type Staff, type StaffWithUser, type SubmitEntryDto, type SuccessResponse, type UpdateBookingStatusDto, type UpdateGymDto, type UpdateMemberProfileDto, type UpdateRewardDto, type User, type UserWithRoles };
+/**
+ * API path constants. Use with your base URL: baseUrl + ROUTES.auth.login
+ * Paths with :param are templates; replace :id, :userId etc. when calling.
+ */
+declare const ROUTES: {
+    readonly health: "/";
+    readonly auth: {
+        readonly register: "/auth/register";
+        readonly login: "/auth/login";
+        readonly deleteMe: "/auth/me";
+    };
+    readonly members: {
+        readonly join: "/members/join";
+        readonly me: "/members/me";
+        readonly meStats: "/members/me/stats";
+    };
+    readonly checkIns: {
+        readonly create: "/check-ins";
+    };
+    readonly leaderboards: {
+        readonly list: "/leaderboards";
+        readonly create: "/leaderboards";
+        readonly submitEntry: "/leaderboards/entries";
+        readonly reviewEntry: "/leaderboards/entries/review";
+    };
+    readonly challenges: {
+        readonly create: "/challenges";
+        readonly createOccurrence: "/challenges/occurrences";
+        readonly meActive: "/challenges/me/active";
+        readonly join: "/challenges/join";
+        readonly complete: "/challenges/complete";
+    };
+    readonly bookings: {
+        readonly create: "/bookings";
+        readonly updateStatus: "/bookings/status";
+        readonly meMember: "/bookings/me/member";
+        readonly meExpert: "/bookings/me/expert";
+    };
+    readonly rewards: {
+        readonly list: "/rewards";
+        readonly me: "/rewards/me";
+    };
+    readonly experts: {
+        readonly list: "/experts";
+        readonly me: "/experts/me";
+        readonly availability: (id: string) => string;
+        readonly meAvailability: "/experts/me/availability";
+        readonly meAvailabilityExceptions: "/experts/me/availability-exceptions";
+    };
+    readonly notifications: {
+        readonly me: "/notifications/me";
+        readonly meReadAll: "/notifications/me/read-all";
+    };
+    readonly activities: {
+        readonly me: "/activities/me";
+    };
+    readonly media: {
+        readonly upload: "/media";
+        readonly delete: (id: string) => string;
+    };
+    readonly admin: {
+        readonly summary: "/admin/summary";
+        readonly gym: "/admin/gym";
+        readonly members: "/admin/members";
+        readonly createMember: "/admin/members";
+        readonly rewards: "/admin/rewards";
+        readonly createReward: "/admin/rewards";
+        readonly rewardById: (id: string) => string;
+        readonly staff: "/admin/staff";
+        readonly createStaff: "/admin/staff";
+        readonly staffByUserId: (userId: string) => string;
+        readonly staffDisable: (userId: string) => string;
+        readonly staffEnable: (userId: string) => string;
+        readonly experts: "/admin/experts";
+        readonly createExpert: "/admin/experts";
+        readonly expertByUserId: (userId: string) => string;
+        readonly expertDisable: (userId: string) => string;
+        readonly expertEnable: (userId: string) => string;
+    };
+};
+type Routes = typeof ROUTES;
+
+/**
+ * Typed API routes: path + method + request/response types in one place.
+ * Use with a generic fetch helper to get full type safety.
+ *
+ * @example
+ * // In your frontend API client:
+ * import { apiRoutes, type RequestBody, type ResponseBody } from '@athos-sdk/api-types';
+ *
+ * const data = await fetchJson(apiRoutes.auth.login, { email, password });
+ * // data is typed as AuthResponse
+ *
+ * type LoginBody = RequestBody<typeof apiRoutes.auth.login>;
+ * type LoginResponse = ResponseBody<typeof apiRoutes.auth.login>;
+ */
+
+/** HTTP method for a route */
+type HttpMethod = 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
+/**
+ * Typed route definition. Request body is void for GET/DELETE with no body.
+ * Use RequestBody<R> and ResponseBody<R> to infer types from a route constant.
+ */
+interface RouteDef<M extends HttpMethod, Req = void, Res = unknown> {
+    method: M;
+    path: string;
+    /** @internal Used for type inference only */
+    _req?: Req;
+    /** @internal Used for type inference only */
+    _res?: Res;
+}
+/** Extract request body type from a RouteDef (void if no body). */
+type RequestBody<R> = R extends RouteDef<HttpMethod, infer Req, unknown> ? Req : never;
+/** Extract response type from a RouteDef. */
+type ResponseBody<R> = R extends RouteDef<HttpMethod, unknown, infer Res> ? Res : never;
+/** Extract HTTP method from a RouteDef. */
+type RouteMethod<R> = R extends RouteDef<infer M, unknown, unknown> ? M : never;
+/** Extract path string from a RouteDef. */
+type RoutePath<R> = R extends RouteDef<HttpMethod, unknown, unknown> ? R['path'] : never;
+declare const apiRoutes: {
+    readonly auth: {
+        readonly register: {
+            method: "POST";
+            path: string;
+            _req: RegisterDto;
+            _res: RegisterResponse;
+        };
+        readonly login: {
+            method: "POST";
+            path: string;
+            _req: LoginDto;
+            _res: AuthResponse;
+        };
+        readonly deleteMe: {
+            method: "DELETE";
+            path: string;
+        };
+    };
+    readonly members: {
+        readonly join: {
+            method: "POST";
+            path: string;
+            _req: JoinGymDto;
+            _res: MemberWithGym;
+        };
+        readonly me: {
+            method: "GET";
+            path: string;
+        };
+        readonly updateMe: {
+            method: "PATCH";
+            path: string;
+            _req: UpdateMemberProfileDto;
+            _res: GetMeResponse;
+        };
+        readonly meStats: {
+            method: "GET";
+            path: string;
+        };
+    };
+    readonly checkIns: {
+        readonly create: {
+            method: "POST";
+            path: string;
+            _req: CreateCheckInDto;
+            _res: CheckIn;
+        };
+    };
+    readonly leaderboards: {
+        readonly list: {
+            method: "GET";
+            path: string;
+        };
+        readonly create: {
+            method: "POST";
+            path: string;
+            _req: CreateLeaderboardDto;
+            _res: Leaderboard;
+        };
+        readonly submitEntry: {
+            method: "POST";
+            path: string;
+            _req: SubmitEntryDto;
+            _res: unknown;
+        };
+        readonly reviewEntry: {
+            method: "POST";
+            path: string;
+            _req: ReviewEntryDto;
+            _res: SuccessResponse;
+        };
+    };
+    readonly challenges: {
+        readonly create: {
+            method: "POST";
+            path: string;
+            _req: CreateChallengeDto;
+            _res: Challenge;
+        };
+        readonly createOccurrence: {
+            method: "POST";
+            path: string;
+            _req: CreateOccurrenceDto;
+            _res: ChallengeOccurrence;
+        };
+        readonly meActive: {
+            method: "GET";
+            path: string;
+        };
+        readonly join: {
+            method: "POST";
+            path: string;
+            _req: JoinChallengeDto;
+            _res: unknown;
+        };
+        readonly complete: {
+            method: "POST";
+            path: string;
+            _req: CompleteChallengeDto;
+            _res: unknown;
+        };
+    };
+    readonly bookings: {
+        readonly create: {
+            method: "POST";
+            path: string;
+            _req: CreateBookingDto;
+            _res: Booking;
+        };
+        readonly updateStatus: {
+            method: "POST";
+            path: string;
+            _req: UpdateBookingStatusDto;
+            _res: Booking;
+        };
+        readonly meMember: {
+            method: "GET";
+            path: string;
+        };
+        readonly meExpert: {
+            method: "GET";
+            path: string;
+        };
+    };
+    readonly rewards: {
+        readonly list: {
+            method: "GET";
+            path: string;
+        };
+        readonly me: {
+            method: "GET";
+            path: string;
+        };
+    };
+    readonly experts: {
+        readonly list: {
+            method: "GET";
+            path: string;
+        };
+        readonly me: {
+            method: "GET";
+            path: string;
+        };
+        readonly availability: (id: string) => RouteDef<"GET", void, ExpertAvailabilityResponse>;
+        readonly meAvailability: {
+            method: "POST";
+            path: string;
+            _req: SetAvailabilityDto;
+            _res: ExpertAvailability[];
+        };
+        readonly meAvailabilityExceptions: {
+            method: "POST";
+            path: string;
+            _req: SetAvailabilityExceptionDto;
+            _res: unknown;
+        };
+    };
+    readonly notifications: {
+        readonly me: {
+            method: "GET";
+            path: string;
+        };
+        readonly meReadAll: {
+            method: "POST";
+            path: string;
+        };
+    };
+    readonly activities: {
+        readonly me: {
+            method: "GET";
+            path: string;
+        };
+    };
+    readonly media: {
+        readonly upload: {
+            method: "POST";
+            path: string;
+            _res: Media;
+        };
+        readonly delete: (id: string) => RouteDef<"DELETE", void, SuccessResponse>;
+    };
+    readonly admin: {
+        readonly summary: {
+            method: "GET";
+            path: string;
+        };
+        readonly gym: {
+            method: "GET";
+            path: string;
+        };
+        readonly updateGym: {
+            method: "PATCH";
+            path: string;
+            _req: UpdateGymDto;
+            _res: Gym;
+        };
+        readonly members: {
+            method: "GET";
+            path: string;
+        };
+        readonly createMember: {
+            method: "POST";
+            path: string;
+            _req: AddMemberDto;
+            _res: MemberWithUser;
+        };
+        readonly rewards: {
+            method: "GET";
+            path: string;
+        };
+        readonly createReward: {
+            method: "POST";
+            path: string;
+            _req: CreateRewardDto;
+            _res: Reward;
+        };
+        readonly updateReward: (id: string) => RouteDef<"PATCH", UpdateRewardDto, Reward>;
+        readonly deleteReward: (id: string) => RouteDef<"DELETE", void, SuccessResponse>;
+        readonly staff: {
+            method: "GET";
+            path: string;
+        };
+        readonly createStaff: {
+            method: "POST";
+            path: string;
+            _req: AddStaffDto;
+            _res: StaffWithUser;
+        };
+        readonly deleteStaff: (userId: string) => RouteDef<"DELETE", void, SuccessResponse>;
+        readonly disableStaff: (userId: string) => RouteDef<"PATCH", void, SuccessResponse>;
+        readonly enableStaff: (userId: string) => RouteDef<"PATCH", void, SuccessResponse>;
+        readonly experts: {
+            method: "GET";
+            path: string;
+        };
+        readonly createExpert: {
+            method: "POST";
+            path: string;
+            _req: AddExpertDto;
+            _res: ExpertWithUser;
+        };
+        readonly deleteExpert: (userId: string) => RouteDef<"DELETE", void, SuccessResponse>;
+        readonly disableExpert: (userId: string) => RouteDef<"PATCH", void, SuccessResponse>;
+        readonly enableExpert: (userId: string) => RouteDef<"PATCH", void, SuccessResponse>;
+    };
+};
+
+/**
+ * Axios-compatible API client. Use with your axios instance for typed requests.
+ * No axios dependency: pass any client that matches AthosHttpClient.
+ */
+
+/**
+ * Minimal axios-like interface so you can pass an axios instance without adding axios as a dependency.
+ * Axios instances satisfy this (request returns { data }).
+ */
+interface AthosHttpClient {
+    request<T = unknown>(config: {
+        method: string;
+        url: string;
+        data?: unknown;
+        params?: Record<string, string>;
+        headers?: Record<string, string>;
+    }): Promise<{
+        data: T;
+    }>;
+}
+/**
+ * Perform a typed request. Route carries the path, method, and (via types) request/response types.
+ *
+ * @example
+ * const api = createApi(axios.create({ baseURL: 'https://api.example.com' }));
+ * const auth = await api.request(apiRoutes.auth.login, { email: 'a@b.com', password: 'x' });
+ * // auth is AuthResponse
+ */
+declare function request<R extends RouteDef<HttpMethod, unknown, unknown>>(client: AthosHttpClient, baseUrl: string, route: R, body?: RequestBody<R>): Promise<ResponseBody<R>>;
+/**
+ * Create an API helper that uses your axios (or compatible) instance.
+ * Use .request(route, body?) for full type inference: route gives you the path, and TypeScript
+ * enforces the body type and infers the response type.
+ *
+ * @example
+ * import axios from 'axios';
+ * import { createApi, apiRoutes } from '@athos-sdk/api-types';
+ *
+ * const api = createApi(axios.create({ baseURL: 'https://api.example.com' }));
+ *
+ * // POST with body – body and response are typed from the route
+ * const auth = await api.request(apiRoutes.auth.login, { email: 'u@x.com', password: 'p' });
+ *
+ * // GET – no body
+ * const me = await api.request(apiRoutes.members.me);
+ *
+ * // Dynamic path
+ * const availability = await api.request(apiRoutes.experts.availability(expertId));
+ */
+declare function createApi(client: AthosHttpClient, baseUrl?: string): {
+    /**
+     * Execute a typed request. The route defines method + path; body and response types are inferred.
+     */
+    request<R extends RouteDef<HttpMethod, unknown, unknown>>(route: R, body?: RequestBody<R>): Promise<ResponseBody<R>>;
+};
+
+export { type Activity, type AddExpertDto, type AddMemberDto, type AddStaffDto, type AdminSummaryResponse, type AthosHttpClient, type AuthResponse, type AvailabilitySlotDto, type Booking, BookingStatus, type Challenge, type ChallengeOccurrence, type ChallengeOccurrenceWithDetails, type ChallengeParticipation, ChallengeVerificationType, type CheckIn, type CompleteChallengeDto, type CreateBookingDto, type CreateChallengeDto, type CreateCheckInDto, type CreateLeaderboardDto, type CreateOccurrenceDto, type CreateRewardDto, type Expert, type ExpertAvailability, type ExpertAvailabilityException, type ExpertAvailabilityResponse, ExpertRole, type ExpertWithUser, type GetMeResponse, type Gym, type HttpMethod, type JoinChallengeDto, type JoinGymDto, type Leaderboard, type LeaderboardEntry, LeaderboardEntryStatus, type LeaderboardWithEntries, type Level, type LoginDto, type Media, type Member, type MemberReward, type MemberStatsResponse, type MemberWithGym, type MemberWithUser, type Notification, ROUTES, type RegisterDto, type RegisterResponse, type RequestBody, type ResponseBody, type ReviewEntryDto, type Reward, type RouteDef, type RouteMethod, type RoutePath, type Routes, type SetAvailabilityDto, type SetAvailabilityExceptionDto, type Staff, type StaffWithUser, type SubmitEntryDto, type SuccessResponse, type UpdateBookingStatusDto, type UpdateGymDto, type UpdateMemberProfileDto, type UpdateRewardDto, type User, type UserWithRoles, apiRoutes, createApi, request };