@simpleapps-com/augur-api/dist/cjs/services/items/resources/inv-mast.d.ts

TypeScript client library for Augur microservices API endpoints

import { ProductListParams, InvMastLookupParams, GetStockParams, CreateItemAttributeValueRequest, CreateInvMastFaqRequest, UpdateInvMastFaqRequest, InvMastLocationsBinsParams, UpdateItemAttributeValueRequest } from '../schemas';
import type { ItemsClient } from '../client';
type ExecuteRequest = ItemsClient['executeRequest'];
/**
 * Creates the invMast resource methods
 * OpenAPI Path: /inv-mast → invMast.*
 * @description Inventory Master endpoints
 */
export declare function createInvMastResource(executeRequest: ExecuteRequest): {
    /**
     * List inventory masters
     * @description Retrieve a paginated list of inventory master items
     * @fullPath api.items.invMast.list
     * @service items
     * @domain inventory-management
     * @discoverable true
     */
    list: (params?: ProductListParams) => 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;
    }>;
    /**
     * OpenAPI Path: /inv-mast/lookup → invMast.lookup.get
     * @description Lookup endpoint for inventory master
     */
    lookup: {
        /**
         * Lookup inventory master items
         * @description Search for inventory master items using lookup functionality
         * @fullPath api.items.invMast.lookup.get
         * @service items
         * @domain inventory-management
         * @discoverable true
         */
        get: (params?: InvMastLookupParams) => 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;
        }>;
    };
    /**
     * Get inventory master details
     * @description Retrieve specific inventory master item details
     * @fullPath api.items.invMast.get
     * @service items
     * @domain inventory-management
     * @discoverable true
     */
    get: (invMastUid: number) => Promise<{
        params: Record<string, unknown> | unknown[];
        data: {
            invMastUid: number;
        } & {
            [k: string]: unknown;
        };
        options: Record<string, unknown> | unknown[];
        status: number;
        message: string;
        count: number;
        total: number;
        totalResults: number;
    }>;
    /**
     * OpenAPI Path: /inv-mast/{invMastUid}/alternate-code → invMast.alternateCode.list
     * @description Nested path for alternate codes
     */
    alternateCode: {
        /**
         * List alternate codes for inventory master
         * @description Get alternate codes for a specific inventory master item
         * @fullPath api.items.invMast.alternateCode.list
         * @service items
         * @domain inventory-management
         * @discoverable true
         */
        list: (invMastUid: number) => Promise<{
            params: Record<string, unknown> | unknown[];
            data: import("zod").objectInputType<{
                alternateCodeUid: import("zod").ZodNumber;
            }, import("zod").ZodTypeAny, "passthrough">[];
            options: Record<string, unknown> | unknown[];
            status: number;
            message: string;
            count: number;
            total: number;
            totalResults: number;
        }>;
    };
    /**
     * OpenAPI Path: /inv-mast/{invMastUid}/attributes → invMast.attributes.*
     * @description Nested path for inventory master attributes
     */
    attributes: {
        /**
         * List inventory master attributes
         * @description Get attributes for a specific inventory master item
         * @fullPath api.items.invMast.attributes.list
         * @service items
         * @domain inventory-management
         * @discoverable true
         */
        list: (invMastUid: number, params?: Record<string, unknown>) => Promise<{
            params: Record<string, unknown> | unknown[];
            data: import("zod").objectInputType<{
                itemAttributeValueUid: import("zod").ZodNumber;
            }, import("zod").ZodTypeAny, "passthrough">[];
            options: Record<string, unknown> | unknown[];
            status: number;
            message: string;
            count: number;
            total: number;
            totalResults: number;
        }>;
        /**
         * Create inventory master attribute
         * @description Create attribute association for inventory master item
         * @fullPath api.items.invMast.attributes.create
         * @service items
         * @domain inventory-management
         * @discoverable true
         */
        create: (invMastUid: number, data: CreateItemAttributeValueRequest) => Promise<{
            params: Record<string, unknown> | unknown[];
            data: {
                itemAttributeValueUid: number;
            } & {
                [k: string]: unknown;
            };
            options: Record<string, unknown> | unknown[];
            status: number;
            message: string;
            count: number;
            total: number;
            totalResults: number;
        }>;
        /**
         * OpenAPI Path: /inv-mast/{invMastUid}/attributes/{attributeUid}/values → invMast.attributes.values.*
         * @description Deep nested path for inventory master attribute values
         */
        values: {
            /**
             * List inventory master attribute values
             * @description Get attribute values for a specific attribute of an inventory master item
             * @fullPath api.items.invMast.attributes.values.list
             * @service items
             * @domain inventory-management
             * @discoverable true
             */
            list: (invMastUid: number, attributeUid: number, params?: Record<string, unknown>) => Promise<{
                params: Record<string, unknown> | unknown[];
                data: import("zod").objectInputType<{
                    itemAttributeValueUid: import("zod").ZodNumber;
                }, import("zod").ZodTypeAny, "passthrough">[];
                options: Record<string, unknown> | unknown[];
                status: number;
                message: string;
                count: number;
                total: number;
                totalResults: number;
            }>;
            /**
             * Create inventory master attribute value
             * @description Create attribute value for a specific attribute of an inventory master item
             * @fullPath api.items.invMast.attributes.values.create
             * @service items
             * @domain inventory-management
             * @discoverable true
             */
            create: (invMastUid: number, attributeUid: number, data: CreateItemAttributeValueRequest) => Promise<{
                params: Record<string, unknown> | unknown[];
                data: {
                    itemAttributeValueUid: number;
                } & {
                    [k: string]: unknown;
                };
                options: Record<string, unknown> | unknown[];
                status: number;
                message: string;
                count: number;
                total: number;
                totalResults: number;
            }>;
            /**
             * Update inventory master attribute value
             * @description Update attribute value for a specific attribute of an inventory master item
             * @fullPath api.items.invMast.attributes.values.update
             * @service items
             * @domain inventory-management
             * @discoverable true
             */
            update: (invMastUid: number, attributeUid: number, attributeValueUid: number, data: UpdateItemAttributeValueRequest) => Promise<{
                params: Record<string, unknown> | unknown[];
                data: {
                    itemAttributeValueUid: number;
                } & {
                    [k: string]: unknown;
                };
                options: Record<string, unknown> | unknown[];
                status: number;
                message: string;
                count: number;
                total: number;
                totalResults: number;
            }>;
            /**
             * Delete inventory master attribute value
             * @description Delete attribute value for a specific attribute of an inventory master item
             * @fullPath api.items.invMast.attributes.values.delete
             * @service items
             * @domain inventory-management
             * @discoverable true
             */
            delete: (invMastUid: number, attributeUid: number, attributeValueUid: number) => Promise<{
                params: Record<string, unknown> | unknown[];
                data: {
                    itemAttributeValueUid: number;
                } & {
                    [k: string]: unknown;
                };
                options: Record<string, unknown> | unknown[];
                status: number;
                message: string;
                count: number;
                total: number;
                totalResults: number;
            }>;
        };
    };
    /**
     * OpenAPI Path: /inv-mast/{invMastUid}/doc → invMast.doc.list
     * @description Nested path for inventory master documents
     */
    doc: {
        /**
         * List inventory master documents
         * @description Get documents for a specific inventory master item
         * @fullPath api.items.invMast.doc.list
         * @service items
         * @domain inventory-management
         * @discoverable true
         */
        list: (invMastUid: number, params?: Record<string, unknown>) => Promise<{
            params: Record<string, unknown> | unknown[];
            data: string | import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough"> | import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">[] | null;
            options: Record<string, unknown> | unknown[];
            status: number;
            message: string;
            count: number;
            total: number;
            totalResults: number;
        }>;
    };
    /**
     * OpenAPI Path: /inv-mast/{invMastUid}/faq → invMast.faq.*
     * @description Nested path for inventory master FAQs
     */
    faq: {
        /**
         * List inventory master FAQs
         * @description Get FAQs for a specific inventory master item
         * @fullPath api.items.invMast.faq.list
         * @service items
         * @domain inventory-management
         * @discoverable true
         */
        list: (invMastUid: number, params?: Record<string, unknown>) => Promise<{
            params: Record<string, unknown> | unknown[];
            data: import("zod").objectInputType<{
                invMastFaqUid: import("zod").ZodNumber;
            }, import("zod").ZodTypeAny, "passthrough">[];
            options: Record<string, unknown> | unknown[];
            status: number;
            message: string;
            count: number;
            total: number;
            totalResults: number;
        }>;
        /**
         * Create inventory master FAQ
         * @description Create FAQ for a specific inventory master item
         * @fullPath api.items.invMast.faq.create
         * @service items
         * @domain inventory-management
         * @discoverable true
         */
        create: (invMastUid: number, data: CreateInvMastFaqRequest) => Promise<{
            params: Record<string, unknown> | unknown[];
            data: {
                invMastFaqUid: number;
            } & {
                [k: string]: unknown;
            };
            options: Record<string, unknown> | unknown[];
            status: number;
            message: string;
            count: number;
            total: number;
            totalResults: number;
        }>;
        /**
         * Get inventory master FAQ
         * @description Get specific FAQ for an inventory master item
         * @fullPath api.items.invMast.faq.get
         * @service items
         * @domain inventory-management
         * @discoverable true
         */
        get: (invMastUid: number, invMastFaqUid: number) => Promise<{
            params: Record<string, unknown> | unknown[];
            data: {
                invMastFaqUid: number;
            } & {
                [k: string]: unknown;
            };
            options: Record<string, unknown> | unknown[];
            status: number;
            message: string;
            count: number;
            total: number;
            totalResults: number;
        }>;
        /**
         * Update inventory master FAQ
         * @description Update FAQ for a specific inventory master item
         * @fullPath api.items.invMast.faq.update
         * @service items
         * @domain inventory-management
         * @discoverable true
         */
        update: (invMastUid: number, invMastFaqUid: number, data: UpdateInvMastFaqRequest) => Promise<{
            params: Record<string, unknown> | unknown[];
            data: {
                invMastFaqUid: number;
            } & {
                [k: string]: unknown;
            };
            options: Record<string, unknown> | unknown[];
            status: number;
            message: string;
            count: number;
            total: number;
            totalResults: number;
        }>;
        /**
         * Delete inventory master FAQ
         * @description Delete FAQ for a specific inventory master item
         * @fullPath api.items.invMast.faq.delete
         * @service items
         * @domain inventory-management
         * @discoverable true
         */
        delete: (invMastUid: number, invMastFaqUid: number) => Promise<{
            params: Record<string, unknown> | unknown[];
            data: {
                invMastFaqUid: number;
            } & {
                [k: string]: unknown;
            };
            options: Record<string, unknown> | unknown[];
            status: number;
            message: string;
            count: number;
            total: number;
            totalResults: number;
        }>;
    };
    /**
     * OpenAPI Path: /inv-mast/{invMastUid}/inv-accessory → invMast.invAccessory.list
     * @description Nested path for inventory master accessories
     */
    invAccessory: {
        /**
         * List inventory master accessories
         * @description Get accessories for a specific inventory master item
         * @fullPath api.items.invMast.invAccessory.list
         * @service items
         * @domain inventory-management
         * @discoverable true
         */
        list: (invMastUid: number) => Promise<{
            params: Record<string, unknown> | unknown[];
            data: import("zod").objectInputType<{
                accessoryUid: import("zod").ZodNumber;
            }, import("zod").ZodTypeAny, "passthrough">[];
            options: Record<string, unknown> | unknown[];
            status: number;
            message: string;
            count: number;
            total: number;
            totalResults: number;
        }>;
    };
    /**
     * OpenAPI Path: /inv-mast/{invMastUid}/inv-sub → invMast.invSub.list
     * @description Nested path for inventory master sub items
     */
    invSub: {
        /**
         * List inventory master sub items
         * @description Get sub items for a specific inventory master item
         * @fullPath api.items.invMast.invSub.list
         * @service items
         * @domain inventory-management
         * @discoverable true
         */
        list: (invMastUid: number) => Promise<{
            params: Record<string, unknown> | unknown[];
            data: import("zod").objectInputType<{
                subPartUid: import("zod").ZodNumber;
            }, import("zod").ZodTypeAny, "passthrough">[];
            options: Record<string, unknown> | unknown[];
            status: number;
            message: string;
            count: number;
            total: number;
            totalResults: number;
        }>;
    };
    /**
     * OpenAPI Path: /inv-mast/{invMastUid}/locations → invMast.locations.*
     * @description Deep nested path for inventory master locations
     */
    locations: {
        /**
         * OpenAPI Path: /inv-mast/{invMastUid}/locations/{locationId}/bins → invMast.locations.bins.*
         * @description Deep nested path for inventory master location bins
         */
        bins: {
            /**
             * List inventory master location bins
             * @description Get bins for a specific location of an inventory master item
             * @fullPath api.items.invMast.locations.bins.list
             * @service items
             * @domain inventory-management
             * @discoverable true
             */
            list: (invMastUid: number, locationId: number, params?: InvMastLocationsBinsParams) => Promise<{
                params: Record<string, unknown> | unknown[];
                data: Record<string, unknown>[];
                options: Record<string, unknown> | unknown[];
                status: number;
                message: string;
                count: number;
                total: number;
                totalResults: number;
            }>;
            /**
             * Get inventory master location bin
             * @description Get specific bin for a location of an inventory master item
             * @fullPath api.items.invMast.locations.bins.get
             * @service items
             * @domain inventory-management
             * @discoverable true
             */
            get: (invMastUid: number, locationId: number, bin: string) => Promise<{
                params: Record<string, unknown> | unknown[];
                data: Record<string, unknown>;
                options: Record<string, unknown> | unknown[];
                status: number;
                message: string;
                count: number;
                total: number;
                totalResults: number;
            }>;
        };
    };
    /**
     * OpenAPI Path: /inv-mast/{invMastUid}/similar → invMast.similar.list
     * @description Nested path for similar inventory master items
     */
    similar: {
        /**
         * List similar inventory master items
         * @description Get similar items for a specific inventory master item
         * @fullPath api.items.invMast.similar.list
         * @service items
         * @domain inventory-management
         * @discoverable true
         */
        list: (invMastUid: number) => 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;
        }>;
    };
    /**
     * OpenAPI Path: /inv-mast/{invMastUid}/stock → invMast.stock.get
     * @description Nested path for inventory master stock (single object)
     */
    stock: {
        /**
         * Get inventory master stock information
         * @description Get stock information for a specific inventory master item
         * @fullPath api.items.invMast.stock.get
         * @service items
         * @domain inventory-management
         * @discoverable true
         */
        get: (invMastUid: number, params?: GetStockParams) => Promise<{
            params: Record<string, unknown> | unknown[];
            data: {
                stockData?: import("zod").objectInputType<{
                    locationId: import("zod").ZodNumber;
                }, import("zod").ZodTypeAny, "passthrough">[] | undefined;
            } & {
                [k: string]: unknown;
            };
            options: Record<string, unknown> | unknown[];
            status: number;
            message: string;
            count: number;
            total: number;
            totalResults: number;
        }>;
    };
};
/**
 * Creates the invMastData resource methods (data-only versions)
 */
export declare function createInvMastDataResource(invMast: ReturnType<typeof createInvMastResource>): {
    list: (params?: ProductListParams) => Promise<import("zod").objectInputType<{
        invMastUid: import("zod").ZodNumber;
    }, import("zod").ZodTypeAny, "passthrough">[]>;
    lookup: {
        get: (params?: InvMastLookupParams) => Promise<import("zod").objectInputType<{
            invMastUid: import("zod").ZodNumber;
        }, import("zod").ZodTypeAny, "passthrough">[]>;
    };
    get: (invMastUid: number) => Promise<{
        invMastUid: number;
    } & {
        [k: string]: unknown;
    }>;
    alternateCode: {
        list: (invMastUid: number) => Promise<import("zod").objectInputType<{
            alternateCodeUid: import("zod").ZodNumber;
        }, import("zod").ZodTypeAny, "passthrough">[]>;
    };
    attributes: {
        list: (invMastUid: number, params?: Record<string, unknown>) => Promise<import("zod").objectInputType<{
            itemAttributeValueUid: import("zod").ZodNumber;
        }, import("zod").ZodTypeAny, "passthrough">[]>;
        values: {
            list: (invMastUid: number, attributeUid: number, params?: Record<string, unknown>) => Promise<import("zod").objectInputType<{
                itemAttributeValueUid: import("zod").ZodNumber;
            }, import("zod").ZodTypeAny, "passthrough">[]>;
        };
    };
    doc: {
        list: (invMastUid: number, params?: Record<string, unknown>) => Promise<string | import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough"> | import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">[] | null>;
    };
    faq: {
        list: (invMastUid: number, params?: Record<string, unknown>) => Promise<import("zod").objectInputType<{
            invMastFaqUid: import("zod").ZodNumber;
        }, import("zod").ZodTypeAny, "passthrough">[]>;
        get: (invMastUid: number, invMastFaqUid: number) => Promise<{
            invMastFaqUid: number;
        } & {
            [k: string]: unknown;
        }>;
    };
    invAccessory: {
        list: (invMastUid: number) => Promise<import("zod").objectInputType<{
            accessoryUid: import("zod").ZodNumber;
        }, import("zod").ZodTypeAny, "passthrough">[]>;
    };
    invSub: {
        list: (invMastUid: number) => Promise<import("zod").objectInputType<{
            subPartUid: import("zod").ZodNumber;
        }, import("zod").ZodTypeAny, "passthrough">[]>;
    };
    locations: {
        bins: {
            list: (invMastUid: number, locationId: number, params?: InvMastLocationsBinsParams) => Promise<Record<string, unknown>[]>;
            get: (invMastUid: number, locationId: number, bin: string) => Promise<Record<string, unknown>>;
        };
    };
    similar: {
        list: (invMastUid: number) => Promise<import("zod").objectInputType<{
            invMastUid: import("zod").ZodNumber;
        }, import("zod").ZodTypeAny, "passthrough">[]>;
    };
    stock: {
        get: (invMastUid: number, params?: GetStockParams) => Promise<{
            stockData?: import("zod").objectInputType<{
                locationId: import("zod").ZodNumber;
            }, import("zod").ZodTypeAny, "passthrough">[] | undefined;
        } & {
            [k: string]: unknown;
        }>;
    };
};
export type InvMastResource = ReturnType<typeof createInvMastResource>;
export type InvMastDataResource = ReturnType<typeof createInvMastDataResource>;
export {};
//# sourceMappingURL=inv-mast.d.ts.map