@simpleapps-com/augur-api/dist/cjs/services/items/resources/item-category.d.ts

TypeScript client library for Augur microservices API endpoints

import { CategoryListParams, CategoryLookupParams } from '../schemas';
import type { ItemsClient } from '../client';
type ExecuteRequest = ItemsClient['executeRequest'];
/**
 * Creates the itemCategory resource methods
 * OpenAPI Path: /item-category → itemCategory.*
 * @description Methods for managing item categories
 */
export declare function createItemCategoryResource(executeRequest: ExecuteRequest): {
    /**
     * List item categories
     * @description Retrieve a paginated list of item categories with filtering options
     * @fullPath api.items.itemCategory.list
     * @service items
     * @domain inventory-management
     * @discoverable true
     */
    list: (params?: CategoryListParams) => Promise<{
        params: Record<string, unknown> | unknown[];
        data: import("zod").objectInputType<{
            itemCategoryUid: import("zod").ZodNumber;
        }, import("zod").ZodTypeAny, "passthrough">[];
        options: Record<string, unknown> | unknown[];
        status: number;
        message: string;
        count: number;
        total: number;
        totalResults: number;
    }>;
    /**
     * OpenAPI Path: /item-category/lookup → itemCategory.lookup.get
     * @description Lookup endpoint for item categories
     */
    lookup: {
        /**
         * Lookup item categories
         * @description Search for item categories using lookup functionality
         * @fullPath api.items.itemCategory.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 item category details
     * @description Retrieve specific item category details
     * @fullPath api.items.itemCategory.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: /item-category/{itemCategoryUid}/doc → itemCategory.doc.list
     * @description Nested path for item category documents
     */
    doc: {
        /**
         * List item category documents
         * @description Get documents for a specific item category
         * @fullPath api.items.itemCategory.doc.list
         * @service items
         * @domain inventory-management
         * @discoverable true
         */
        list: (itemCategoryUid: number) => Promise<{
            params: Record<string, unknown> | unknown[];
            data: import("zod").objectInputType<{
                itemCategoryUid: import("zod").ZodNumber;
            }, import("zod").ZodTypeAny, "passthrough">[];
            options: Record<string, unknown> | unknown[];
            status: number;
            message: string;
            count: number;
            total: number;
            totalResults: number;
        }>;
    };
};
/**
 * Creates the itemCategoryData resource methods (data-only versions)
 */
export declare function createItemCategoryDataResource(itemCategory: ReturnType<typeof createItemCategoryResource>): {
    list: (params?: CategoryListParams) => Promise<import("zod").objectInputType<{
        itemCategoryUid: import("zod").ZodNumber;
    }, import("zod").ZodTypeAny, "passthrough">[]>;
    lookup: {
        get: (params?: CategoryLookupParams) => Promise<{
            itemCategoryUid: number;
        } & {
            [k: string]: unknown;
        }>;
    };
    get: (itemCategoryUid: number) => Promise<{
        itemCategoryUid: number;
    } & {
        [k: string]: unknown;
    }>;
    doc: {
        list: (itemCategoryUid: number) => Promise<import("zod").objectInputType<{
            itemCategoryUid: import("zod").ZodNumber;
        }, import("zod").ZodTypeAny, "passthrough">[]>;
    };
};
export type ItemCategoryResource = ReturnType<typeof createItemCategoryResource>;
export type ItemCategoryDataResource = ReturnType<typeof createItemCategoryDataResource>;
export {};
//# sourceMappingURL=item-category.d.ts.map