@temboplus/afloat 0.1.81 → 0.2.0-beta.2

package/package.json

@@ -1,37 +1,63 @@
 {
   "name": "@temboplus/afloat",
-  "version": "0.1.81",
-  "description": "A JavaScript/TypeScript package providing common utilities and logic shared across all Temboplus-Afloat Projects",
+  "version": "0.2.0-beta.2",
+  "description": "A foundational library for Temboplus-Afloat projects.",
+  "main": "./dist/index.cjs.js",
+  "module": "./dist/index.esm.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.esm.js",
+      "require": "./dist/index.cjs.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rollup -c rollup.config.js",
+    "prepare": "npm run build",
+    "dev": "npm run build -- --watch",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/TemboPlus-Frontend/afloat-js"
+    "url": "git+https://github.com/TemboPlus-Frontend/afloat-js.git"
   },
+  "keywords": [
+    "temboplus",
+    "afloat"
+  ],
+  "author": "Okello Gerald",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/TemboPlus-Frontend/afloat-js/issues"
   },
-  "main": "./script/mod.js",
-  "module": "./esm/mod.js",
-  "exports": {
-    ".": {
-      "import": "./esm/mod.js",
-      "require": "./script/mod.js"
-    }
-  },
-  "scripts": {
-    "test": "node test_runner.js"
-  },
-  "private": false,
-  "dependencies": {
-    "@temboplus/frontend-core": "^0.2.22",
+  "homepage": "https://github.com/TemboPlus-Frontend/afloat-js#readme",
+  "peerDependencies": {
     "@ts-rest/core": "^3.52.1",
-    "antd": "^5.24.2",
+    "tslib": "^2.8.1",
     "uuid": "^11.1.0",
-    "zod": "^3.24.2"
+    "zod": "^3.24.2",
+    "zustand": "^5.0.9"
   },
   "devDependencies": {
-    "@types/node": "^20.9.0",
-    "picocolors": "^1.0.0"
+    "@rollup/plugin-alias": "^6.0.0",
+    "@rollup/plugin-commonjs": "^29.0.0",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^12.3.0",
+    "@types/jest": "^30.0.0",
+    "jest": "^30.2.0",
+    "rollup": "^4.53.3",
+    "ts-jest": "^29.4.6",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
   },
-  "_generatedBy": "dnt@dev"
-}
+  "dependencies": {
+    "@temboplus/frontend-core": "^0.3.0-beta.1"
+  }
+}

package/LICENSE

@@ -1,7 +0,0 @@
-Copyright (c) 2025 TemboPlus Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/esm/mod.d.ts

@@ -1,8 +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";
-//# sourceMappingURL=mod.d.ts.map

package/esm/mod.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,+BAA+B,CAAC;AAE9C,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC"}

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";