@temboplus/afloat 0.1.60 → 0.1.62

package/esm/mod.js

@@ -1,7 +0,0 @@
-export * from "./src/features/auth/index.js";
-export * from "./src/features/contact/index.js";
-export * from "./src/features/wallet/index.js";
-export * from "./src/features/payout/index.js";
-export * from "./src/features/admin/index.js";
-export * from "./src/errors/index.js";
-export * from "./src/models/index.js";

package/esm/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "module"
-}

package/esm/src/errors/api_error.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"api_error.d.ts","sourceRoot":"","sources":["../../../src/src/errors/api_error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,qBAAa,QAAS,SAAQ,KAAK;IACjC;;;OAGG;IACH,SAAgB,UAAU,EAAE,MAAM,CAAC;IAEnC;;;OAGG;IACH,SAAgB,KAAK,CAAC,EAAE,MAAM,CAAC;IAE/B;;;OAGG;IACH,SAAgB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAElD;;;;;;;OAOG;gBACS,IAAI,EAAE;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;QACnB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACnC;IASD;;;;;;;;;;;;;;;;;OAiBG;WACW,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ;WAKrC,OAAO,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,QAAQ;IAOjD,WAAkB,MAAM,IAAI,CAAC,CAAC,SAAS,CAAC;QACtC,OAAO,EAAE,CAAC,CAAC,SAAS,CAAC;QACrB,UAAU,EAAE,CAAC,CAAC,SAAS,CAAC;QACxB,KAAK,EAAE,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;QAClC,OAAO,EAAE,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;KACxC,CAAC,CAOD;CACF"}

package/esm/src/errors/api_error.js

@@ -1,90 +0,0 @@
-import { z } from "zod";
-/**
- * Custom error class representing API-related errors.
- * Extends the built-in `Error` class to include additional properties such as `statusCode`, `error`, and `details`.
- */
-export class APIError extends Error {
-    /**
-     * Creates a new `APIError` instance.
-     * @param {Object} args - The arguments to initialize the error.
-     * @param {string} args.message - The error message.
-     * @param {number} args.statusCode - The HTTP status code associated with the error.
-     * @param {string} [args.error] - An optional error identifier or code.
-     * @param {Record<string, unknown>} [args.details] - Additional details about the error.
-     */
-    constructor(args) {
-        super(args.message);
-        /**
-         * The HTTP status code associated with the error.
-         * @type {number}
-         */
-        Object.defineProperty(this, "statusCode", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /**
-         * An optional error identifier or code.
-         * @type {string | undefined}
-         */
-        Object.defineProperty(this, "error", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /**
-         * Additional details about the error, often used for debugging purposes.
-         * @type {Record<string, unknown> | undefined}
-         */
-        Object.defineProperty(this, "details", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.name = "ApiError";
-        this.statusCode = args.statusCode;
-        if (this.error)
-            this.error = args.error;
-        if (args.details)
-            this.details = args.details;
-    }
-    /**
-     * Validates whether an unknown value conforms to the APIError schema.
-     * This is more thorough than an instanceof check as it verifies all required properties
-     * and their types using the defined schema.
-     *
-     * @param {unknown} error - Any value to be validated
-     * @returns {error is APIError} Type predicate indicating if the value is a valid APIError
-     *
-     * @example
-     * try {
-     *   throw new Error('Network failed');
-     * } catch (err) {
-     *   if (APIError.is(err)) {
-     *     // err is typed as APIError here
-     *     console.log(err.statusCode);
-     *   }
-     * }
-     */
-    static is(error) {
-        const result = APIError.schema.safeParse(error);
-        return result.success;
-    }
-    static unknown(message) {
-        return new APIError({
-            message: message ?? "An unknown error occurred",
-            statusCode: 502,
-        });
-    }
-    static get schema() {
-        return z.object({
-            message: z.string(),
-            statusCode: z.number().int(),
-            error: z.string().optional(),
-            details: z.object({}).optional(),
-        });
-    }
-}

package/esm/src/errors/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./api_error.js";
-export * from "./permission_error.js";
-//# sourceMappingURL=index.d.ts.map

package/esm/src/errors/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/src/errors/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC"}

package/esm/src/errors/index.js

@@ -1,2 +0,0 @@
-export * from "./api_error.js";
-export * from "./permission_error.js";

package/esm/src/errors/permission_error.d.ts

@@ -1,48 +0,0 @@
-import { type Permission } from "../models/permission.js";
-/**
- * Custom error class representing an error caused by missing required permissions.
- * Extends the built-in {@link Error} class to include the `requiredPermissions` property.
- */
-export declare class PermissionError extends Error {
-    /**
-     * The permissions that are required but were not present, causing the error.
-     * @type {Permission[]}
-     */
-    readonly requiredPermissions: Permission[];
-    /**
-     * Creates a new `PermissionError` instance.
-     * @param {Object} args - The constructor arguments.
-     * @param {Permission[]} args.requiredPermissions - An array of permissions required for the operation.
-     * @param {string} [args.message] - An optional custom error message. Defaults to listing the missing permissions.
-     */
-    constructor(args: {
-        requiredPermissions: Permission[];
-        message?: string;
-    });
-    /**
-     * Validates if an unknown value is a valid PermissionError instance.
-     * Performs structural validation of the error object and its properties.
-     *
-     * @param {unknown} error - The value to validate.
-     * @returns {error is PermissionError} Type predicate indicating if the value is a valid PermissionError.
-     *
-     * @example
-     * try {
-     *   throw new Error('Access denied');
-     * } catch (error) {
-     *   if (PermissionError.is(error)) {
-     *     // error is typed as PermissionError with properly typed requiredPermissions
-     *     console.log(error.requiredPermissions);
-     *   }
-     * }
-     *
-     * @remarks
-     * Validates the following:
-     * - Has all required Error properties
-     * - Has correct error name
-     * - Contains properly structured requiredPermissions array
-     * - Maintains proper prototype chain
-     */
-    static is(error: unknown): error is PermissionError;
-}
-//# sourceMappingURL=permission_error.d.ts.map

package/esm/src/errors/permission_error.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"permission_error.d.ts","sourceRoot":"","sources":["../../../src/src/errors/permission_error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAe,MAAM,yBAAyB,CAAC;AAGvE;;;GAGG;AACH,qBAAa,eAAgB,SAAQ,KAAK;IACxC;;;OAGG;IACH,SAAgB,mBAAmB,EAAE,UAAU,EAAE,CAAC;IAElD;;;;;OAKG;gBACS,IAAI,EAAE;QAChB,mBAAmB,EAAE,UAAU,EAAE,CAAC;QAClC,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB;IASD;;;;;;;;;;;;;;;;;;;;;;;OAuBG;WACW,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,eAAe;CAkB3D"}

package/esm/src/errors/permission_error.js

@@ -1,70 +0,0 @@
-import { Permissions } from "../models/permission.js";
-import { z } from "zod";
-/**
- * Custom error class representing an error caused by missing required permissions.
- * Extends the built-in {@link Error} class to include the `requiredPermissions` property.
- */
-export class PermissionError extends Error {
-    /**
-     * Creates a new `PermissionError` instance.
-     * @param {Object} args - The constructor arguments.
-     * @param {Permission[]} args.requiredPermissions - An array of permissions required for the operation.
-     * @param {string} [args.message] - An optional custom error message. Defaults to listing the missing permissions.
-     */
-    constructor(args) {
-        super(args.message ??
-            `Missing required permissions: ${args.requiredPermissions.join(", ")}`);
-        /**
-         * The permissions that are required but were not present, causing the error.
-         * @type {Permission[]}
-         */
-        Object.defineProperty(this, "requiredPermissions", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.name = "PermissionError";
-        this.requiredPermissions = args.requiredPermissions;
-    }
-    /**
-     * Validates if an unknown value is a valid PermissionError instance.
-     * Performs structural validation of the error object and its properties.
-     *
-     * @param {unknown} error - The value to validate.
-     * @returns {error is PermissionError} Type predicate indicating if the value is a valid PermissionError.
-     *
-     * @example
-     * try {
-     *   throw new Error('Access denied');
-     * } catch (error) {
-     *   if (PermissionError.is(error)) {
-     *     // error is typed as PermissionError with properly typed requiredPermissions
-     *     console.log(error.requiredPermissions);
-     *   }
-     * }
-     *
-     * @remarks
-     * Validates the following:
-     * - Has all required Error properties
-     * - Has correct error name
-     * - Contains properly structured requiredPermissions array
-     * - Maintains proper prototype chain
-     */
-    static is(error) {
-        const permissionSchema = z.union([
-            z.enum(Object.values(Permissions.Profile)),
-            z.enum(Object.values(Permissions.Contact)),
-            z.enum(Object.values(Permissions.Payment)),
-            z.enum(Object.values(Permissions.Payout)),
-            z.enum(Object.values(Permissions.Transfer)),
-            z.enum(Object.values(Permissions.Wallet)),
-        ]);
-        const errorSchema = z.object({
-            name: z.literal("PermissionError"),
-            message: z.string(),
-            requiredPermissions: z.array(permissionSchema),
-        });
-        return errorSchema.safeParse(error).success;
-    }
-}

package/esm/src/features/admin/contract.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../../src/src/features/admin/contract.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsNjC,CAAC;AAEH;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAAG,OAAO,sBAAsB,CAAC"}

package/esm/src/features/admin/contract.js

@@ -1,210 +0,0 @@
-import { initContract } from "@ts-rest/core";
-import { z } from "zod";
-import { UserManagementSchemas } from "./schemas.js";
-// ====================== API Contract ====================== //
-const c = initContract();
-export const userManagementContract = c.router({
-    // List all users
-    getUsers: {
-        method: "GET",
-        path: "/login",
-        query: UserManagementSchemas.managedUserQueryParams,
-        responses: {
-            200: z.array(UserManagementSchemas.managedUser),
-            401: z.object({
-                message: z.string().optional(),
-            }),
-            403: z.object({
-                message: z.string().optional(),
-            }),
-        },
-        summary: "List all user accounts",
-        description: "Retrieve a list of all user accounts in the system",
-    },
-    // Get user by ID
-    getUser: {
-        method: "GET",
-        path: "/login/:id",
-        pathParams: z.object({
-            id: z.string(),
-        }),
-        query: UserManagementSchemas.managedUserQueryParams,
-        responses: {
-            200: UserManagementSchemas.managedUser,
-            401: z.object({
-                message: z.string().optional(),
-            }),
-            403: z.object({
-                message: z.string().optional(),
-            }),
-            404: z.object({
-                message: z.string().optional(),
-            }),
-        },
-        summary: "Get user account details",
-        description: "Retrieve detailed information about a specific user account",
-    },
-    // Create new user
-    createUser: {
-        method: "POST",
-        path: "/login",
-        body: UserManagementSchemas.createUserRequest,
-        responses: {
-            201: UserManagementSchemas.createUserResponse,
-            400: z.object({
-                message: z.string().optional(),
-                errors: z.array(z.string()).optional(),
-            }),
-            401: z.object({
-                message: z.string().optional(),
-            }),
-            403: z.object({
-                message: z.string().optional(),
-            }),
-            409: z.object({
-                message: z.string().optional(),
-            }),
-        },
-        summary: "Create new user account",
-        description: "Create a new user account with specified role and permissions",
-    },
-    // Update user
-    updateUser: {
-        method: "PATCH",
-        path: "/login/:id",
-        pathParams: z.object({
-            id: z.string(),
-        }),
-        body: UserManagementSchemas.updateUserRequest,
-        responses: {
-            200: UserManagementSchemas.managedUser,
-            400: z.object({
-                message: z.string().optional(),
-                errors: z.array(z.string()).optional(),
-            }),
-            401: z.object({
-                message: z.string().optional(),
-            }),
-            403: z.object({
-                message: z.string().optional(),
-            }),
-            404: z.object({
-                message: z.string().optional(),
-            }),
-        },
-        summary: "Update user account",
-        description: "Update user account information, role, status, or force password reset",
-    },
-    // Archive user (soft delete)
-    archiveUser: {
-        method: "POST",
-        path: "/login/:id/archive",
-        pathParams: z.object({
-            id: z.string(),
-        }),
-        body: z.object({}),
-        responses: {
-            200: UserManagementSchemas.managedUser,
-            401: z.object({
-                message: z.string().optional(),
-            }),
-            403: z.object({
-                message: z.string().optional(),
-            }),
-            404: z.object({
-                message: z.string().optional(),
-            }),
-        },
-        summary: "Archive user account",
-        description: "Archive (soft delete) a user account",
-    },
-    // Archive user (soft delete)
-    unArchiveUser: {
-        method: "POST",
-        path: "/login/:id/unarchive",
-        pathParams: z.object({
-            id: z.string(),
-        }),
-        body: z.object({}),
-        responses: {
-            200: UserManagementSchemas.managedUser,
-            401: z.object({
-                message: z.string().optional(),
-            }),
-            403: z.object({
-                message: z.string().optional(),
-            }),
-            404: z.object({
-                message: z.string().optional(),
-            }),
-        },
-        summary: "Un-archive user account",
-        description: "Un-archive (soft delete) a user account",
-    },
-    // Reset user password
-    resetPassword: {
-        method: "POST",
-        path: "/login/:id/reset-password",
-        pathParams: z.object({
-            id: z.string(),
-        }),
-        body: UserManagementSchemas.resetPasswordRequest,
-        responses: {
-            200: z.object({
-                success: z.boolean(),
-            }),
-            400: z.object({
-                message: z.string().optional(),
-            }),
-            401: z.object({
-                message: z.string().optional(),
-            }),
-            403: z.object({
-                message: z.string().optional(),
-            }),
-            404: z.object({
-                message: z.string().optional(),
-            }),
-        },
-        summary: "Reset user password",
-        description: "Reset a user's password and optionally send notification",
-    },
-    // Get all roles
-    getRoles: {
-        method: "GET",
-        path: "/role",
-        responses: {
-            200: z.array(UserManagementSchemas.role),
-            401: z.object({
-                message: z.string().optional(),
-            }),
-            403: z.object({
-                message: z.string().optional(),
-            }),
-        },
-        summary: "List all roles",
-        description: "Retrieve a list of all available roles in the system",
-    },
-    // Get role by ID
-    getRole: {
-        method: "GET",
-        path: "/role/:id",
-        pathParams: z.object({
-            id: z.string(),
-        }),
-        responses: {
-            200: UserManagementSchemas.role,
-            401: z.object({
-                message: z.string().optional(),
-            }),
-            403: z.object({
-                message: z.string().optional(),
-            }),
-            404: z.object({
-                message: z.string().optional(),
-            }),
-        },
-        summary: "Get role details",
-        description: "Retrieve detailed information about a specific role",
-    },
-});

package/esm/src/features/admin/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./contract.js";
-export * from "./repository.js";
-export * from "./schemas.js";
-//# sourceMappingURL=index.d.ts.map

package/esm/src/features/admin/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/src/features/admin/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,cAAc,CAAA"}

package/esm/src/features/admin/index.js

@@ -1,3 +0,0 @@
-export * from "./contract.js";
-export * from "./repository.js";
-export * from "./schemas.js";

package/esm/src/features/admin/repository.d.ts

@@ -1,114 +0,0 @@
-import { BaseRepository } from "../../shared/base_repository.js";
-import { userManagementContract } from "./contract.js";
-import type { CreateUserRequest, CreateUserResponse, ManagedUserQueryParams, ResetPasswordRequest, UpdateUserRequest } from "./schemas.js";
-import type { AfloatAuth } from "../auth/manager.js";
-import { ManagedUser } from "../../models/index.js";
-import { Role } from "../../models/role.js";
-/**
- * Repository class for managing user accounts through API interactions.
- * Extends the `BaseRepository` to leverage shared functionality.
- */
-export declare class UserManagementRepository extends BaseRepository<typeof userManagementContract> {
-    /**
-     * Creates an instance of `UserManagementRepository` using the user management contract.
-     * @param {Object} [props] - Optional constructor properties
-     * @param {AfloatAuth} [props.auth] - Optional auth instance to use
-     * @param {string} [props.root] - Optional API root URL
-     */
-    constructor(props?: {
-        auth?: AfloatAuth;
-        root?: string;
-    });
-    /**
-     * Creates a new user account.
-     * @param {CreateUserRequest} input - The data required to create a new user account.
-     * @returns {Promise<CreateUserResponse>} A promise that resolves to the newly created user response.
-     * @throws {PermissionError} If the user lacks required permissions
-     * @throws {APIError} If the response status code is not 201.
-     */
-    createUser(input: CreateUserRequest): Promise<CreateUserResponse>;
-    /**
-     * Updates an existing user account by ID.
-     * @param {string} id - The unique identifier of the user account to update.
-     * @param {UpdateUserRequest} input - The data to update the user account with.
-     * @returns {Promise<ManagedUser>} A promise that resolves to the updated user account.
-     * @throws {PermissionError} If the user lacks required permissions
-     * @throws {APIError} If the response status code is not 200.
-     */
-    updateUser(id: string, input: UpdateUserRequest): Promise<ManagedUser>;
-    /**
-     * Archives (soft deletes) a user account by ID.
-     * @param {string} id - The unique identifier of the user account to archive.
-     * @returns {Promise<ManagedUser>} A promise with the updated user object.
-     * @throws {PermissionError} If the user lacks required permissions
-     * @throws {APIError} If the response status code is not 200.
-     */
-    archiveUser(id: string): Promise<ManagedUser>;
-    /**
-     * Archives (soft deletes) a user account by ID.
-     * @param {string} id - The unique identifier of the user account to archive.
-     * @returns {Promise<ManagedUser>} A promise with the updated user object.
-     * @throws {PermissionError} If the user lacks required permissions
-     * @throws {APIError} If the response status code is not 200.
-     */
-    unArchiveUser(id: string): Promise<ManagedUser>;
-    /**
-     * Resets a user's password.
-     * @param {string} id - The unique identifier of the user account.
-     * @param {ResetPasswordRequest} [input] - Optional password reset configuration.
-     * @returns {Promise<void>} A promise that resolves when the password reset is complete.
-     * @throws {PermissionError} If the user lacks required permissions
-     * @throws {APIError} If the response status code is not 200.
-     */
-    resetUserPassword(id: string, input?: ResetPasswordRequest): Promise<{
-        success: boolean;
-    }>;
-    /**
-     * Retrieves all user accounts.
-     * Results are ordered in descending order by creation date by default.
-     *
-     * @returns {Promise<ManagedUser[]>} A promise that resolves to an array of managed users.
-     * @throws {PermissionError} If the user lacks required permissions
-     * @throws {APIError} If the response status code is not 200.
-     * @example
-     * const repository = new UserManagementRepository();
-     * repository.getAllUsers().then(users => console.log(users));
-     */
-    getAllUsers(query?: ManagedUserQueryParams): Promise<ManagedUser[]>;
-    /**
-     * Retrieves a specific user account by ID.
-     *
-     * @param {string} id - The unique identifier of the user account to retrieve.
-     * @returns {Promise<ManagedUser>} A promise that resolves to the managed user.
-     * @throws {PermissionError} If the user lacks required permissions
-     * @throws {APIError} If the response status code is not 200 or user not found.
-     * @example
-     * const repository = new UserManagementRepository();
-     * repository.getUser('user-id').then(user => console.log(user));
-     */
-    getUser(id: string, query?: ManagedUserQueryParams): Promise<ManagedUser>;
-    /**
-     * Retrieves all available roles in the system.
-     *
-     * @returns {Promise<Role[]>} A promise that resolves to an array of roles.
-     * @throws {PermissionError} If the user lacks required permissions
-     * @throws {APIError} If the response status code is not 200.
-     * @example
-     * const repository = new UserManagementRepository();
-     * repository.getAllRoles().then(roles => console.log(roles));
-     */
-    getAllRoles(): Promise<Role[]>;
-    /**
-     * Retrieves a specific role by ID.
-     *
-     * @param {string} id - The unique identifier of the role to retrieve.
-     * @returns {Promise<Role>} A promise that resolves to the role.
-     * @throws {PermissionError} If the user lacks required permissions
-     * @throws {APIError} If the response status code is not 200 or role not found.
-     * @example
-     * const repository = new UserManagementRepository();
-     * repository.getRole('role-id').then(role => console.log(role));
-     */
-    getRole(id: string): Promise<Role>;
-}
-//# sourceMappingURL=repository.d.ts.map

package/esm/src/features/admin/repository.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../../../../src/src/features/admin/repository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,KAAK,EACV,iBAAiB,EACjB,kBAAkB,EAClB,sBAAsB,EACtB,oBAAoB,EACpB,iBAAiB,EAClB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EACL,WAAW,EAGZ,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,IAAI,EAAiB,MAAM,sBAAsB,CAAC;AAE3D;;;GAGG;AACH,qBAAa,wBACX,SAAQ,cAAc,CAAC,OAAO,sBAAsB,CAAC;IACrD;;;;;OAKG;gBACS,KAAK,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,UAAU,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE;IAIxD;;;;;;OAMG;IACG,UAAU,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAgBvE;;;;;;;OAOG;IACG,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,WAAW,CAAC;IAuB5E;;;;;;OAMG;IACG,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAoBnD;;;;;;OAMG;IACG,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAoBrD;;;;;;;OAOG;IACG,iBAAiB,CACrB,EAAE,EAAE,MAAM,EACV,KAAK,GAAE,oBAAyB,GAC/B,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;IAkBhC;;;;;;;;;;OAUG;IACG,WAAW,CACf,KAAK,GAAE,sBAA0C,GAChD,OAAO,CAAC,WAAW,EAAE,CAAC;IAgBzB;;;;;;;;;;OAUG;IACG,OAAO,CACX,EAAE,EAAE,MAAM,EACV,KAAK,GAAE,sBAA0C,GAChD,OAAO,CAAC,WAAW,CAAC;IAoBvB;;;;;;;;;OASG;IACG,WAAW,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;IAsBpC;;;;;;;;;;OAUG;IACG,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAmBzC"}