@simpleapps-com/augur-api/dist/esm/services/vmi/resources/distributors.js

TypeScript client library for Augur microservices API endpoints

import { z } from 'zod';
import { DistributorListParamsSchema, DistributorListResponseSchema, DistributorResponseSchema, CreateDistributorRequestSchema, UpdateDistributorRequestSchema, EnableDistributorRequestSchema, ProductResponseSchema, CreateProductRequestSchema, } from '../schemas';
/**
 * Creates the distributors resource methods
 * OpenAPI Path: /distributors → distributors.*
 * @description Methods for CRUD operations on distributors and supplier relationships
 */
export function createDistributorsResource(executeRequest) {
    const resource = {
        /**
         * List distributors with filtering
         * @description Returns distributors for a customer with optional status filtering and pagination
         * @param params Filtering and pagination parameters (customerId is required)
         * @returns Array of distributor objects
         * @throws ValidationError When parameters are invalid or response is malformed
         */
        list: async (params) => {
            return executeRequest({
                method: 'GET',
                path: '/distributors',
                paramsSchema: DistributorListParamsSchema,
                responseSchema: DistributorListResponseSchema,
            }, params);
        },
        /**
         * Get distributor details by ID
         * @description Returns detailed information for a specific distributor
         * @param distributorsUid Distributor unique identifier
         * @returns Distributor details
         * @throws ValidationError When response is malformed
         */
        get: async (distributorsUid) => {
            return executeRequest({
                method: 'GET',
                path: `/distributors/${distributorsUid}`,
                responseSchema: DistributorResponseSchema,
            }, undefined);
        },
        /**
         * Create a new distributor
         * @description Creates a new distributor with contact information
         * @param request Distributor creation data
         * @returns Created distributor information
         * @throws ValidationError When request is invalid or response is malformed
         */
        create: async (request) => {
            return executeRequest({
                method: 'POST',
                path: '/distributors',
                paramsSchema: CreateDistributorRequestSchema,
                responseSchema: DistributorResponseSchema,
            }, request);
        },
        /**
         * Update distributor information
         * @description Updates distributor details with provided data
         * @param distributorsUid Distributor unique identifier
         * @param request Distributor update data
         * @returns Updated distributor information
         * @throws ValidationError When request is invalid or response is malformed
         */
        update: async (distributorsUid, request) => {
            return executeRequest({
                method: 'PUT',
                path: `/distributors/${distributorsUid}`,
                paramsSchema: UpdateDistributorRequestSchema,
                responseSchema: DistributorResponseSchema,
            }, request);
        },
        /**
         * Soft delete a distributor
         * @description Marks distributor as deleted without removing data
         * @param distributorsUid Distributor unique identifier
         * @returns Boolean indicating successful deletion
         * @throws ValidationError When response is malformed
         */
        delete: async (distributorsUid) => {
            await executeRequest({
                method: 'DELETE',
                path: `/distributors/${distributorsUid}`,
                responseSchema: z.unknown(),
            });
            return true;
        },
        /**
         * Enable, disable, or delete a distributor
         * @description Changes distributor status using status codes
         * @param distributorsUid Distributor unique identifier
         * @param request Status change request with new status code
         * @returns Updated distributor information
         * @throws ValidationError When request is invalid or response is malformed
         */
        enable: async (distributorsUid, request) => {
            return executeRequest({
                method: 'PUT',
                path: '/distributors/{distributorsUid}/enable',
                paramsSchema: EnableDistributorRequestSchema,
                responseSchema: DistributorResponseSchema,
            }, request, { distributorsUid: String(distributorsUid) });
        },
        /**
         * Distributor products endpoints
         * @description Methods for managing products associated with distributors
         */
        products: {
            /**
             * Create product associated with distributor
             * @description Creates a new product and associates it with a distributor
             * @param distributorsUid Distributor unique identifier
             * @param request Product creation data
             * @returns Created product information
             * @throws ValidationError When request is invalid or response is malformed
             */
            create: async (distributorsUid, request) => {
                return executeRequest({
                    method: 'POST',
                    path: '/distributors/{distributorsUid}/products',
                    paramsSchema: CreateProductRequestSchema,
                    responseSchema: ProductResponseSchema,
                }, request, { distributorsUid: String(distributorsUid) });
            },
        },
    };
    return resource;
}
/**
 * Creates the distributorsData resource methods (data-only versions)
 */
export function createDistributorsDataResource(distributors) {
    return {
        list: async (params) => {
            const response = await distributors.list(params);
            return response.data;
        },
        get: async (distributorsUid) => {
            const response = await distributors.get(distributorsUid);
            return response.data;
        },
        create: async (request) => {
            const response = await distributors.create(request);
            return response.data;
        },
        update: async (distributorsUid, request) => {
            const response = await distributors.update(distributorsUid, request);
            return response.data;
        },
        enable: async (distributorsUid, request) => {
            const response = await distributors.enable(distributorsUid, request);
            return response.data;
        },
        products: {
            create: async (distributorsUid, request) => {
                const response = await distributors.products.create(distributorsUid, request);
                return response.data;
            },
        },
    };
}
//# sourceMappingURL=distributors.js.map