@temboplus/afloat 0.1.54 → 0.1.55

package/esm/src/features/auth/storage/server_store.js

@@ -1,34 +0,0 @@
-/**
- * Server-side implementation of AuthStore.
- * Maintains user state in memory for the duration of a request.
- */
-export class ServerStore {
-    constructor() {
-        Object.defineProperty(this, "user", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-    }
-    /**
-     * Retrieves the current user from memory.
-     * @returns {User | undefined} The current user or undefined if not set
-     */
-    getUser() {
-        return this.user;
-    }
-    /**
-     * Sets the current user in memory.
-     * @param {User} user - The user to store
-     */
-    setUser(user) {
-        this.user = user;
-    }
-    /**
-     * Clears the stored user from memory.
-     */
-    refresh() {
-        this.user = undefined;
-    }
-}

package/esm/src/features/auth/storage/server_token_handler.d.ts

@@ -1,36 +0,0 @@
-import type { TokenHandler } from "./types.js";
-import { User } from "../../../models/index.js";
-/**
- * Server-side implementation of TokenHandler.
- * Manages tokens in memory for the duration of a request.
- * Uses TokenRequiredRepository instead of repositories that rely on AfloatAuth.
- * @implements {TokenHandler}
- */
-export declare class ServerTokenHandler implements TokenHandler {
-    private token;
-    private accessRepo;
-    private profileRepo;
-    private identityRepo;
-    /**
-     * Creates a new instance of ServerTokenHandler.
-     * @param {string} [token] - Optional initial token value
-     */
-    constructor(token: string);
-    /**
-     * Returns the stored token.
-     * @returns {string | undefined} The current token or undefined if not set
-     */
-    getUserToken(): string | undefined;
-    /**
-     * Stores the provided token in memory.
-     * @param {string} token - The token to store
-     */
-    setUserToken(token: string): void;
-    clearToken(): void;
-    /**
-     * Fetches and constructs the full user data
-     * @returns {Promise<User>}
-     */
-    constructUser(token: string): Promise<User>;
-}
-//# sourceMappingURL=server_token_handler.d.ts.map

package/esm/src/features/auth/storage/server_token_handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"server_token_handler.d.ts","sourceRoot":"","sources":["../../../../../src/src/features/auth/storage/server_token_handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAW,IAAI,EAAE,MAAM,0BAA0B,CAAC;AAMzD;;;;;GAKG;AACH,qBAAa,kBAAmB,YAAW,YAAY;IACrD,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,UAAU,CAAiD;IACnE,OAAO,CAAC,WAAW,CAAkD;IACrE,OAAO,CAAC,YAAY,CAAmD;IAEvE;;;OAGG;gBACS,KAAK,EAAE,MAAM;IAqBzB;;;OAGG;IACH,YAAY,IAAI,MAAM,GAAG,SAAS;IAIlC;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAOjC,UAAU,IAAI,IAAI;IAOlB;;;OAGG;IACG,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAoDlD"}

package/esm/src/features/auth/storage/server_token_handler.js

@@ -1,115 +0,0 @@
-import { Profile, User } from "../../../models/index.js";
-import { profileContract } from "../profile/contract.js";
-import { identityContract } from "../identity/contract.js";
-import { TokenRequiredRepository } from "../../../shared/token_required_repository.js";
-import { accessContract } from "../access/contract.js";
-/**
- * Server-side implementation of TokenHandler.
- * Manages tokens in memory for the duration of a request.
- * Uses TokenRequiredRepository instead of repositories that rely on AfloatAuth.
- * @implements {TokenHandler}
- */
-export class ServerTokenHandler {
-    /**
-     * Creates a new instance of ServerTokenHandler.
-     * @param {string} [token] - Optional initial token value
-     */
-    constructor(token) {
-        Object.defineProperty(this, "token", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "accessRepo", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "profileRepo", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "identityRepo", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.token = token;
-        this.accessRepo = new TokenRequiredRepository("auth", accessContract, this.token);
-        this.profileRepo = new TokenRequiredRepository("profile", profileContract, this.token);
-        this.identityRepo = new TokenRequiredRepository("login", identityContract, this.token);
-    }
-    /**
-     * Returns the stored token.
-     * @returns {string | undefined} The current token or undefined if not set
-     */
-    getUserToken() {
-        return this.token;
-    }
-    /**
-     * Stores the provided token in memory.
-     * @param {string} token - The token to store
-     */
-    setUserToken(token) {
-        this.token = token;
-        this.accessRepo.setToken(token);
-        this.profileRepo.setToken(token);
-        this.identityRepo.setToken(token);
-    }
-    clearToken() {
-        this.token = "";
-        this.accessRepo.setToken("");
-        this.profileRepo.setToken("");
-        this.identityRepo.setToken("");
-    }
-    /**
-     * Fetches and constructs the full user data
-     * @returns {Promise<User>}
-     */
-    async constructUser(token) {
-        if (!this.token) {
-            throw new Error("Token is required to construct user");
-        }
-        this.setUserToken(token);
-        try {
-            // Fetch all data concurrently with Promise.all
-            const [access, profileResult, identityResult] = await Promise.all([
-                this.accessRepo.client.getAccessList(),
-                this.profileRepo.client.getCurrentProfile(),
-                this.identityRepo.client.getUserCredentials(),
-            ]);
-            // Extract and validate response data
-            const accessList = this.accessRepo.handleResponse(access, 200);
-            const profileData = this.profileRepo.handleResponse(profileResult, 200);
-            const identityData = this.identityRepo.handleResponse(identityResult, 200);
-            // Create profile object
-            const profile = Profile.from(profileData);
-            if (!profile) {
-                throw new Error("Failed to create profile from response data");
-            }
-            // Construct and return user object
-            const user = User.from({
-                token: this.token,
-                profile,
-                access: accessList,
-                resetPassword: false,
-                ...identityData,
-            });
-            if (!user) {
-                throw new Error("Failed to construct user");
-            }
-            return user;
-        }
-        catch (error) {
-            const message = error instanceof Error
-                ? error.message
-                : "Unknown error occurred";
-            throw new Error(`Error constructing user: ${message}`);
-        }
-    }
-}

package/esm/src/features/auth/storage/types.d.ts

@@ -1,42 +0,0 @@
-import type { User } from "../../../models/user/index.js";
-/**
- * Interface defining the contract for auth storage implementations.
- * This allows for different storage strategies in different environments.
- */
-export interface AuthStore {
-    /**
-     * Retrieves the currently authenticated user.
-     * @returns {User | undefined} The current user or undefined if not authenticated
-     */
-    getUser(): User | undefined;
-    /**
-     * Sets the current authenticated user.
-     * @param {User} user - The user to set as currently authenticated
-     */
-    setUser(user: User): void;
-    /**
-     * Clears the current authentication state.
-     */
-    refresh(): void;
-}
-/**
- * Interface defining the contract for token handling implementations.
- * This allows for different token storage strategies in different environments.
- */
-export interface TokenHandler {
-    /**
-     * Retrieves the current authentication token.
-     * @returns {string | undefined} The current token or undefined if not present
-     */
-    getUserToken(): string | undefined;
-    /**
-     * Sets the authentication token.
-     * @param {string} token - The token to store
-     */
-    setUserToken(token: string): void;
-    /**
-     * Clears the stored authentication token.
-     */
-    clearToken(): void;
-}
-//# sourceMappingURL=types.d.ts.map

package/esm/src/features/auth/storage/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/src/features/auth/storage/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,+BAA+B,CAAC;AAE1D;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB;;;OAGG;IACH,OAAO,IAAI,IAAI,GAAG,SAAS,CAAC;IAE5B;;;OAGG;IACH,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC;IAE1B;;OAEG;IACH,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,YAAY,IAAI,MAAM,GAAG,SAAS,CAAC;IAEnC;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAElC;;OAEG;IACH,UAAU,IAAI,IAAI,CAAC;CACpB"}

package/esm/src/features/auth/storage/types.js

@@ -1 +0,0 @@
-export {};

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

@@ -1 +0,0 @@
-{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../../src/src/features/contact/contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmCnB,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,QAAQ,CAAC"}

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

@@ -1,49 +0,0 @@
-import { z } from "zod";
-import { initContract } from "@ts-rest/core";
-import { commonAPIResponses } from "../../shared/index.js";
-import { ContactSchemas } from "../../models/index.js";
-/**
- * Contact API contract
- * Defines the REST endpoints for managing contacts
- *
- * @property {Object} postContact - Create a new contact (POST /)
- * @property {Object} editContact - Update an existing contact (PATCH /:id)
- * @property {Object} getContacts - Retrieve contacts list (GET /)
- * @property {Object} deleteContact - Delete a contact (DELETE /:id)
- */
-export const contract = initContract().router({
-    postContact: {
-        method: "POST",
-        path: "/",
-        body: ContactSchemas.contactInput,
-        responses: {
-            201: ContactSchemas.contactData,
-        },
-    },
-    editContact: {
-        method: "PATCH",
-        path: "/:id",
-        body: ContactSchemas.contactInput,
-        responses: {
-            200: ContactSchemas.contactData,
-        },
-    },
-    getContacts: {
-        method: "GET",
-        path: "/",
-        query: z.object({ orderByDesc: z.string() }),
-        responses: {
-            200: z.array(ContactSchemas.contactData),
-        },
-    },
-    deleteContact: {
-        method: "DELETE",
-        path: "/:id",
-        body: z.object({}),
-        responses: {
-            200: z.object({}),
-        },
-    },
-}, {
-    commonResponses: commonAPIResponses,
-});

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/src/features/contact/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC"}

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

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

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

@@ -1,58 +0,0 @@
-import { BaseRepository } from "../../shared/base_repository.js";
-import { contract } from "./contract.js";
-import { Contact, type ContactInput } from "../../models/contact/index.js";
-import type { AfloatAuth } from "../auth/manager.js";
-/**
- * Repository class for managing `Contact` data through API interactions.
- * Extends the `BaseRepository` to leverage shared functionality.
- */
-export declare class ContactRepository extends BaseRepository<typeof contract> {
-    /**
-     * Creates an instance of `ContactRepository` using the contact 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 contact record.
-     * @param {ContactInput} input - The data required to create a new contact.
-     * @returns {Promise<Contact>} A promise that resolves to the newly created contact.
-     * @throws {PermissionError} If the user lacks required permissions
-     * @throws {APIError} If the response status code is not 201.
-     */
-    create(input: ContactInput): Promise<Contact>;
-    /**
-     * Updates an existing contact record by ID.
-     * @param {string} id - The unique identifier of the contact to edit.
-     * @param {ContactInput} input - The data to update the contact with.
-     * @returns {Promise<Contact>} A promise that resolves to the updated contact.
-     * @throws {PermissionError} If the user lacks required permissions
-     * @throws {APIError} If the response status code is not 200.
-     */
-    edit(id: string, input: ContactInput): Promise<Contact>;
-    /**
-     * Deletes a contact record by ID.
-     * @param {string} id - The unique identifier of the contact to remove.
-     * @returns {Promise<void>} A promise that resolves when the deletion is complete.
-     * @throws {PermissionError} If the user lacks required permissions
-     * @throws {APIError} If the response status code is not 200.
-     */
-    remove(id: string): Promise<void>;
-    /**
-     * Retrieves all contacts
-     * Results are ordered in descending order by default.
-     *
-     * @returns {Promise<Contact[]>} A promise that resolves to an array of contacts.
-     * @throws {PermissionError} If the user lacks required permissions
-     * @throws {APIError} If the response status code is not 200 or the range is invalid.
-     * @example
-     * const repository = new ContactRepository();
-     * repository.getAll().then(contacts => console.log(contacts));
-     */
-    getAll(): Promise<Contact[]>;
-}
-//# sourceMappingURL=repository.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../../../../src/src/features/contact/repository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EACL,OAAO,EAEP,KAAK,YAAY,EAClB,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAIrD;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,cAAc,CAAC,OAAO,QAAQ,CAAC;IACpE;;;;;OAKG;gBACS,KAAK,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,UAAU,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE;IAIxD;;;;;;OAMG;IACG,MAAM,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC;IAgBnD;;;;;;;OAOG;IACG,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC;IAmB7D;;;;;;OAMG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAevC;;;;;;;;;;OAUG;IACG,MAAM,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;CAgBnC"}

package/esm/src/features/contact/repository.js

@@ -1,108 +0,0 @@
-import { BaseRepository } from "../../shared/base_repository.js";
-import { contract } from "./contract.js";
-import { Contact, } from "../../models/contact/index.js";
-import { Permissions } from "../../models/index.js";
-import { PermissionError } from "../../errors/index.js";
-/**
- * Repository class for managing `Contact` data through API interactions.
- * Extends the `BaseRepository` to leverage shared functionality.
- */
-export class ContactRepository extends BaseRepository {
-    /**
-     * Creates an instance of `ContactRepository` using the contact 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) {
-        super("contact", contract, props);
-    }
-    /**
-     * Creates a new contact record.
-     * @param {ContactInput} input - The data required to create a new contact.
-     * @returns {Promise<Contact>} A promise that resolves to the newly created contact.
-     * @throws {PermissionError} If the user lacks required permissions
-     * @throws {APIError} If the response status code is not 201.
-     */
-    async create(input) {
-        const auth = this.getAuthForPermissionCheck();
-        const requiredPerm = Permissions.Contact.Create;
-        if (!auth.checkPermission(requiredPerm)) {
-            throw new PermissionError({
-                message: "You are not authorized to add contacts.",
-                requiredPermissions: [requiredPerm],
-            });
-        }
-        const result = await this.client.postContact({ body: input });
-        const data = this.handleResponse(result, 201);
-        return Contact.create(data);
-    }
-    /**
-     * Updates an existing contact record by ID.
-     * @param {string} id - The unique identifier of the contact to edit.
-     * @param {ContactInput} input - The data to update the contact with.
-     * @returns {Promise<Contact>} A promise that resolves to the updated contact.
-     * @throws {PermissionError} If the user lacks required permissions
-     * @throws {APIError} If the response status code is not 200.
-     */
-    async edit(id, input) {
-        const auth = this.getAuthForPermissionCheck();
-        const requiredPerm = Permissions.Contact.Update;
-        if (!auth.checkPermission(requiredPerm)) {
-            throw new PermissionError({
-                message: "You are not authorized to update contacts.",
-                requiredPermissions: [requiredPerm],
-            });
-        }
-        const result = await this.client.editContact({
-            params: { id },
-            body: input,
-        });
-        const data = this.handleResponse(result, 200);
-        return Contact.create(data);
-    }
-    /**
-     * Deletes a contact record by ID.
-     * @param {string} id - The unique identifier of the contact to remove.
-     * @returns {Promise<void>} A promise that resolves when the deletion is complete.
-     * @throws {PermissionError} If the user lacks required permissions
-     * @throws {APIError} If the response status code is not 200.
-     */
-    async remove(id) {
-        const auth = this.getAuthForPermissionCheck();
-        const requiredPerm = Permissions.Contact.Delete;
-        if (!auth.checkPermission(requiredPerm)) {
-            throw new PermissionError({
-                message: "You are not authorized to delete contacts.",
-                requiredPermissions: [requiredPerm],
-            });
-        }
-        const result = await this.client.deleteContact({ params: { id } });
-        this.handleResponse(result, 200);
-    }
-    /**
-     * Retrieves all contacts
-     * Results are ordered in descending order by default.
-     *
-     * @returns {Promise<Contact[]>} A promise that resolves to an array of contacts.
-     * @throws {PermissionError} If the user lacks required permissions
-     * @throws {APIError} If the response status code is not 200 or the range is invalid.
-     * @example
-     * const repository = new ContactRepository();
-     * repository.getAll().then(contacts => console.log(contacts));
-     */
-    async getAll() {
-        const auth = this.getAuthForPermissionCheck();
-        const requiredPerm = Permissions.Contact.List;
-        if (!auth.checkPermission(requiredPerm)) {
-            throw new PermissionError({
-                message: "You are not authorized to view contacts.",
-                requiredPermissions: [requiredPerm],
-            });
-        }
-        const query = { orderByDesc: "createdAt" };
-        const result = await this.client.getContacts({ query });
-        const data = this.handleResponse(result, 200);
-        return Contact.createMany(data);
-    }
-}

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

@@ -1 +0,0 @@
-{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../../src/src/features/payout/contract.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,oDAAoD;AACpD,eAAO,MAAM,wBAAwB,2BAA2B,CAAC;AAEjE,6CAA6C;AAC7C,eAAO,MAAM,qBAAqB,cAAc,CAAC;AAEjD;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyDnB,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,QAAQ,CAAC"}

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

@@ -1,75 +0,0 @@
-import { PayoutSchemas } from "../../models/payout/index.js";
-import { APIError } from "../../errors/api_error.js";
-import { initContract } from "@ts-rest/core";
-import { z } from "zod";
-/** Default eager loading settings for payout API */
-export const DEFAULT_PAYOUT_API_EAGER = "[createdBy,actionedBy]";
-/** Default sort order for payout listings */
-export const DEFAULT_ORDER_BY_DESC = "createdAt";
-/**
- * Payout management API contract
- * Defines endpoints for creating and managing payouts
- *
- * @property {Object} getPayouts - List payouts with filtering (GET /)
- * @property {Object} getPayoutsByApprovalStatus - List payouts by approval status (GET /)
- * @property {Object} postPayout - Create new payout (POST /)
- * @property {Object} approve - Approve/reject payout (POST /:id/approve)
- */
-export const contract = initContract().router({
-    getPayouts: {
-        method: "GET",
-        path: "",
-        query: z.object({
-            rangeStart: z.number(),
-            rangeEnd: z.number(),
-            eager: z.string(),
-            approvalStatus: PayoutSchemas.payoutApprovalStatus.nullable().optional(),
-            orderByDesc: z.string(),
-        }),
-        responses: {
-            200: z.object({
-                results: z.array(PayoutSchemas.payoutData),
-                total: z.number(),
-            }),
-        },
-    },
-    getPayoutsByApprovalStatus: {
-        method: "GET",
-        path: "",
-        query: z.object({
-            rangeStart: z.number(),
-            rangeEnd: z.number(),
-            eager: z.string(),
-            approvalStatus: PayoutSchemas.payoutApprovalStatus,
-            orderByDesc: z.string(),
-        }),
-        responses: {
-            200: z.object({
-                results: z.array(PayoutSchemas.payoutData),
-                total: z.number(),
-            }),
-        },
-    },
-    postPayout: {
-        method: "POST",
-        path: "",
-        body: PayoutSchemas.payoutInput,
-        responses: {
-            201: PayoutSchemas.payoutData,
-            400: APIError.schema,
-        },
-    },
-    approve: {
-        method: "POST",
-        path: "/:id/approve",
-        body: z.object({
-            action: z.enum(["Approve", "Reject"]),
-            notes: z.string().optional(),
-        }),
-        responses: {
-            201: PayoutSchemas.payoutData,
-            404: z.object({}),
-            409: z.object({}),
-        },
-    },
-});

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/src/features/payout/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC"}

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

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

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

@@ -1,67 +0,0 @@
-import { BaseRepository } from "../../shared/index.js";
-import { type PayoutAPI } from "./contract.js";
-import { type GetPayoutsAPIArgs, type PayoutInput } from "../../models/payout/index.js";
-import type { AfloatAuth } from "../auth/manager.js";
-import { Payout } from "../../models/payout/derivatives/payout.js";
-/**
- * Repository class for managing payout operations including creation, approval,
- * rejection, and retrieval of payouts.
- * @extends {BaseRepository<PayoutAPI>}
- */
-export declare class PayoutRepository extends BaseRepository<PayoutAPI> {
-    /**
-     * Creates an instance of PayoutRepository initialized with the payout contract.
-     * @param {Object} [props] - Optional constructor properties
-     * @param {AfloatAuth} [props.auth] - Optional auth instance to use
-     */
-    constructor(props?: {
-        auth?: AfloatAuth;
-    });
-    /**
-     * Retrieves a paginated list of payouts with optional filtering for pending status.
-     * @param {GetPayoutsAPIArgs} [args] - Optional arguments for filtering and pagination
-     * @param {number} [args.rangeStart=0] - Starting index for pagination
-     * @param {number} [args.rangeEnd=10] - Ending index for pagination
-     * @param {boolean} [args.pending] - Filter for pending payouts only
-     * @throws {PermissionError} If user lacks the Payout.List permission
-     * @throws {APIError} If range is invalid or if the fetch operation fails
-     * @returns {Promise<{results: Payout[]; total: number}>} Paginated payout results and total count
-     */
-    getAll(args?: GetPayoutsAPIArgs): Promise<{
-        results: Payout[];
-        total: number;
-    }>;
-    /**
-     * Creates a new payout with the provided input data.
-     * @param {PayoutInput} input - The payout creation data
-     * @throws {PermissionError} If user lacks the Payout.Create permission
-     * @throws {APIError} If the input is invalid or if the creation operation fails
-     * @returns {Promise<Payout>} The created payout
-     */
-    pay(input: PayoutInput): Promise<Payout>;
-    /**
-     * Approves a payout with optional notes.
-     * @param {string} id - The ID of the payout to approve
-     * @param {Object} [args] - Optional arguments
-     * @param {string} [args.notes] - Optional notes for the approval
-     * @throws {PermissionError} If user lacks the Payout.Approve permission
-     * @throws {APIError} If payout is not found, already approved, or if the operation fails
-     * @returns {Promise<Payout>} The approved payout
-     */
-    approve(id: string, args?: {
-        notes?: string;
-    }): Promise<Payout>;
-    /**
-     * Rejects a payout with optional notes.
-     * @param {string} id - The ID of the payout to reject
-     * @param {Object} [args] - Optional arguments
-     * @param {string} [args.notes] - Optional notes for the rejection
-     * @throws {PermissionError} If user lacks the Payout.Approve permission
-     * @throws {APIError} If payout is not found, already rejected, or if the operation fails
-     * @returns {Promise<Payout>} The rejected payout
-     */
-    reject(id: string, args?: {
-        notes?: string;
-    }): Promise<Payout>;
-}
-//# sourceMappingURL=repository.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../../../../src/src/features/payout/repository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAY,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,WAAW,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGrD,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAEnE;;;;GAIG;AACH,qBAAa,gBAAiB,SAAQ,cAAc,CAAC,SAAS,CAAC;IAC7D;;;;OAIG;gBACS,KAAK,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,UAAU,CAAA;KAAE;IAIzC;;;;;;;;;OASG;IACG,MAAM,CAAC,IAAI,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC;QAC9C,OAAO,EAAE,MAAM,EAAE,CAAC;QAClB,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IA6CF;;;;;;OAMG;IACG,GAAG,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;IAoB9C;;;;;;;;OAQG;IACG,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAgCrE;;;;;;;;OAQG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC;CA+BrE"}