@simpleapps-com/augur-api/dist/esm/services/items/resources/categories.d.ts

TypeScript client library for Augur microservices API endpoints

import { CategoryLookupParams } from '../schemas';
import type { ItemsClient } from '../client';
type ExecuteRequest = ItemsClient['executeRequest'];
/**
 * Creates the categories resource methods
 * OpenAPI Path: /categories → categories.*
 * @description Methods for managing categories
 */
export declare function createCategoriesResource(executeRequest: ExecuteRequest): {
    /**
     * OpenAPI Path: /categories/lookup → categories.lookup.get
     * @description Lookup endpoint for categories
     */
    lookup: {
        /**
         * Lookup categories
         * @description Search for categories using lookup functionality
         * @fullPath api.items.categories.lookup.get
         * @service items
         * @domain inventory-management
         * @discoverable true
         */
        get: (params?: CategoryLookupParams) => Promise<{
            params: Record<string, unknown> | unknown[];
            data: {
                itemCategoryUid: number;
            } & {
                [k: string]: unknown;
            };
            options: Record<string, unknown> | unknown[];
            status: number;
            message: string;
            count: number;
            total: number;
            totalResults: number;
        }>;
    };
    /**
     * Get category details
     * @description Retrieve comprehensive category information
     * @fullPath api.items.categories.get
     * @service items
     * @domain inventory-management
     * @discoverable true
     */
    get: (itemCategoryUid: number) => Promise<{
        params: Record<string, unknown> | unknown[];
        data: {
            itemCategoryUid: number;
        } & {
            [k: string]: unknown;
        };
        options: Record<string, unknown> | unknown[];
        status: number;
        message: string;
        count: number;
        total: number;
        totalResults: number;
    }>;
    /**
     * OpenAPI Path: /categories/{itemCategoryUid}/attributes → categories.attributes.list
     * @description Nested path for category attributes
     */
    attributes: {
        /**
         * List category attributes
         * @description Get attributes associated with a category
         * @fullPath api.items.categories.attributes.list
         * @service items
         * @domain inventory-management
         * @discoverable true
         */
        list: (itemCategoryUid: number) => Promise<{
            params: Record<string, unknown> | unknown[];
            data: import("zod").objectInputType<{
                attributeUid: import("zod").ZodNumber;
            }, import("zod").ZodTypeAny, "passthrough">[];
            options: Record<string, unknown> | unknown[];
            status: number;
            message: string;
            count: number;
            total: number;
            totalResults: number;
        }>;
    };
    /**
     * OpenAPI Path: /categories/{itemCategoryUid}/images → categories.images.list
     * @description Nested path for category images
     */
    images: {
        /**
         * List category images
         * @description Get images associated with a category
         * @fullPath api.items.categories.images.list
         * @service items
         * @domain inventory-management
         * @discoverable true
         */
        list: (itemCategoryUid: number) => Promise<{
            params: Record<string, unknown> | unknown[];
            data: import("zod").objectInputType<{
                imageUid: import("zod").ZodNumber;
            }, import("zod").ZodTypeAny, "passthrough">[];
            options: Record<string, unknown> | unknown[];
            status: number;
            message: string;
            count: number;
            total: number;
            totalResults: number;
        }>;
    };
    /**
     * OpenAPI Path: /categories/{itemCategoryUid}/items → categories.items.list
     * @description Nested path for category items (plural)
     */
    items: {
        /**
         * List category items
         * @description List items in a category with filtering and search capabilities
         * @fullPath api.items.categories.items.list
         * @service items
         * @domain inventory-management
         * @discoverable true
         * @dataMethod categoriesData.items.list
         * @searchTerms ["category", "items", "products", "list", "filter"]
         * @relatedEndpoints ["categories.get", "invMast.list", "categories.attributes.list"]
         * @commonPatterns ["List items in category", "Filter category products", "Search category items"]
         * @workflow ["inventory-management", "product-discovery"]
         * @prerequisites ["Valid itemCategoryUid", "Bearer token", "x-site-id header", "Required q parameter"]
         * @nextSteps ["Use item details for product display", "Apply filters for refinement"]
         * @businessRules ["Returns array of items", "Requires q search parameter", "Supports pagination and filtering"]
         * @functionalArea "inventory-management"
         * @crossSite true
         * @caching "Variable TTL based on cacheTtl parameter"
         * @performance "Good - supports caching and filtering"
         */
        list: (itemCategoryUid: number, params?: Record<string, unknown>) => Promise<{
            params: Record<string, unknown> | unknown[];
            data: import("zod").objectInputType<{
                invMastUid: import("zod").ZodNumber;
            }, import("zod").ZodTypeAny, "passthrough">[];
            options: Record<string, unknown> | unknown[];
            status: number;
            message: string;
            count: number;
            total: number;
            totalResults: number;
        }>;
    };
};
/**
 * Creates the categoriesData resource methods (data-only versions)
 */
export declare function createCategoriesDataResource(categories: ReturnType<typeof createCategoriesResource>): {
    lookup: {
        get: (params?: CategoryLookupParams) => Promise<{
            itemCategoryUid: number;
        } & {
            [k: string]: unknown;
        }>;
    };
    get: (itemCategoryUid: number) => Promise<{
        itemCategoryUid: number;
    } & {
        [k: string]: unknown;
    }>;
    attributes: {
        list: (itemCategoryUid: number) => Promise<import("zod").objectInputType<{
            attributeUid: import("zod").ZodNumber;
        }, import("zod").ZodTypeAny, "passthrough">[]>;
    };
    images: {
        list: (itemCategoryUid: number) => Promise<import("zod").objectInputType<{
            imageUid: import("zod").ZodNumber;
        }, import("zod").ZodTypeAny, "passthrough">[]>;
    };
    items: {
        list: (itemCategoryUid: number, params?: Record<string, unknown>) => Promise<import("zod").objectInputType<{
            invMastUid: import("zod").ZodNumber;
        }, import("zod").ZodTypeAny, "passthrough">[]>;
    };
};
export type CategoriesResource = ReturnType<typeof createCategoriesResource>;
export type CategoriesDataResource = ReturnType<typeof createCategoriesDataResource>;
export {};
//# sourceMappingURL=categories.d.ts.map