@simpleapps-com/augur-api/dist/cjs/services/vmi/resources/products.d.ts

TypeScript client library for Augur microservices API endpoints

import { z } from 'zod';
import type { BaseResponse } from '../../../core/base-client';
import { Product, ProductFindItem, ProductListParams, ProductFindParams, EnableProductRequest } from '../schemas';
import type { VMIClient } from '../client';
import type { UpdateProductRequest } from '../schemas';
type ExecuteRequest = VMIClient['executeRequest'];
/**
 * Creates the products resource methods
 * OpenAPI Path: /products → products.*
 * @description Methods for CRUD operations on products and product search functionality
 */
export declare function createProductsResource(executeRequest: ExecuteRequest): {
    /**
     * List products with filtering
     * @description Returns products for a customer and distributor with optional filtering and pagination
     * @param params Filtering and pagination parameters (customerId and distributorsUid are required)
     * @returns Array of product objects
     * @throws ValidationError When parameters are invalid or response is malformed
     */
    list: (params?: ProductListParams) => Promise<{
        params: Record<string, unknown> | unknown[];
        data: z.objectInputType<{
            productsUid: z.ZodNumber;
        }, z.ZodTypeAny, "passthrough">[];
        options: Record<string, unknown> | unknown[];
        status: number;
        message: string;
        count: number;
        total: number;
        totalResults: number;
    }>;
    /**
     * Get product details by ID
     * @description Returns detailed information for a specific product
     * @param productsUid Product unique identifier
     * @returns Product details
     * @throws ValidationError When response is malformed
     */
    get: (productsUid: number) => Promise<{
        params: Record<string, unknown> | unknown[];
        data: {
            productsUid: number;
        } & {
            [k: string]: unknown;
        };
        options: Record<string, unknown> | unknown[];
        status: number;
        message: string;
        count: number;
        total: number;
        totalResults: number;
    }>;
    /**
     * Update product information
     * @description Updates product details with provided data
     * @param productsUid Product unique identifier
     * @param request Product update data
     * @returns Updated product information
     * @throws ValidationError When request is invalid or response is malformed
     */
    update: (productsUid: number, request: UpdateProductRequest) => Promise<{
        params: Record<string, unknown> | unknown[];
        data: {
            productsUid: number;
        } & {
            [k: string]: unknown;
        };
        options: Record<string, unknown> | unknown[];
        status: number;
        message: string;
        count: number;
        total: number;
        totalResults: number;
    }>;
    /**
     * Soft delete a product
     * @description Marks product as deleted without removing data
     * @param productsUid Product unique identifier
     * @returns Boolean indicating successful deletion
     * @throws ValidationError When response is malformed
     */
    delete: (productsUid: number) => Promise<boolean>;
    /**
     * Enable, disable, or delete a product
     * @description Changes product status using status codes
     * @param productsUid Product unique identifier
     * @param request Status change request with new status code
     * @returns Updated product information
     * @throws ValidationError When request is invalid or response is malformed
     */
    enable: (productsUid: number, request: EnableProductRequest) => Promise<BaseResponse<Product>>;
    /**
     * Products find endpoints
     * @description Methods for searching products across VMI and Prophet 21
     */
    find: {
        /**
         * Search across both VMI products and Prophet 21 items
         * @description Searches both VMI custom products and Prophet 21 items with prefix matching
         * @param params Search parameters with customer ID and optional prefix filter
         * @returns Array of found items with type indicator (limited to 10 results)
         * @throws ValidationError When parameters are invalid or response is malformed
         */
        get: (params: ProductFindParams) => Promise<BaseResponse<ProductFindItem[]>>;
    };
};
/**
 * Creates the productsData resource methods (data-only versions)
 */
export declare function createProductsDataResource(products: ReturnType<typeof createProductsResource>): {
    list: (params?: ProductListParams) => Promise<z.objectInputType<{
        productsUid: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough">[]>;
    get: (productsUid: number) => Promise<{
        productsUid: number;
    } & {
        [k: string]: unknown;
    }>;
    find: {
        get: (params: ProductFindParams) => Promise<z.objectOutputType<{
            invMastUid: z.ZodNumber;
        }, z.ZodTypeAny, "passthrough">[]>;
    };
};
export type ProductsResource = ReturnType<typeof createProductsResource>;
export type ProductsDataResource = ReturnType<typeof createProductsDataResource>;
export {};
//# sourceMappingURL=products.d.ts.map