@simpleapps-com/augur-api/dist/cjs/services/nexus/resources/receiving.d.ts

TypeScript client library for Augur microservices API endpoints

import { ReceivingListParamsSchema, ReceivingCreateRequestSchema, ReceivingUpdateRequestSchema } from '../schemas';
import type { z } from 'zod';
import type { NexusClient } from '../client';
type ExecuteRequest = NexusClient['executeRequest'];
type ReceivingListParams = z.infer<typeof ReceivingListParamsSchema>;
type ReceivingCreateRequest = z.infer<typeof ReceivingCreateRequestSchema>;
type ReceivingUpdateRequest = z.infer<typeof ReceivingUpdateRequestSchema>;
/**
 * Creates the receiving resource methods
 * OpenAPI Path: /receiving → receiving.*
 * @description Methods for managing receiving operations - purchase order receipts and inventory receiving processes
 */
export declare function createReceivingResource(executeRequest: ExecuteRequest): {
    /**
     * Retrieve a list of receiving documents with optional filtering
     * @description Returns receiving documents with pagination and filtering by PO number or status
     * @fullPath api.nexus.receiving.list
     * @service nexus
     * @domain warehouse-management
     * @dataMethod receivingData.list
     * @discoverable true
     */
    list: (params?: ReceivingListParams) => Promise<{
        params: Record<string, unknown> | unknown[];
        data: z.objectInputType<{
            receivingUid: z.ZodNumber;
        }, z.ZodTypeAny, "passthrough">[];
        options: Record<string, unknown> | unknown[];
        status: number;
        message: string;
        count: number;
        total: number;
        totalResults: number;
    }>;
    /**
     * Retrieve details for a specific receiving document
     * @description Returns complete details for a receiving document including JSON data and properties
     * @fullPath api.nexus.receiving.get
     * @service nexus
     * @domain warehouse-management
     * @dataMethod receivingData.get
     * @discoverable true
     */
    get: (receivingUid: number | string) => Promise<{
        params: Record<string, unknown> | unknown[];
        data: {
            receivingUid: number;
        } & {
            [k: string]: unknown;
        };
        options: Record<string, unknown> | unknown[];
        status: number;
        message: string;
        count: number;
        total: number;
        totalResults: number;
    }>;
    /**
     * Create a new receiving document
     * @description Creates a receiving document for purchase order receipt processing
     * @fullPath api.nexus.receiving.create
     * @service nexus
     * @domain warehouse-management
     * @dataMethod receivingData.create
     * @discoverable true
     */
    create: (receivingData: ReceivingCreateRequest) => Promise<{
        params: Record<string, unknown> | unknown[];
        data: {
            receivingUid: number;
        } & {
            [k: string]: unknown;
        };
        options: Record<string, unknown> | unknown[];
        status: number;
        message: string;
        count: number;
        total: number;
        totalResults: number;
    }>;
    /**
     * Update an existing receiving document
     * @description Updates receiving status, process codes, messages, and tracking information
     * @fullPath api.nexus.receiving.update
     * @service nexus
     * @domain warehouse-management
     * @dataMethod receivingData.update
     * @discoverable true
     */
    update: (receivingUid: number | string, updateData: ReceivingUpdateRequest) => Promise<{
        params: Record<string, unknown> | unknown[];
        data: {
            receivingUid: number;
        } & {
            [k: string]: unknown;
        };
        options: Record<string, unknown> | unknown[];
        status: number;
        message: string;
        count: number;
        total: number;
        totalResults: number;
    }>;
    /**
     * Soft delete a receiving document
     * @description Marks a receiving document as deleted by setting status code to 700
     * @fullPath api.nexus.receiving.delete
     * @service nexus
     * @domain warehouse-management
     * @dataMethod receivingData.delete
     * @discoverable true
     */
    delete: (receivingUid: number | string) => Promise<{
        params: Record<string, unknown> | unknown[];
        data: {
            receivingUid: number;
        } & {
            [k: string]: unknown;
        };
        options: Record<string, unknown> | unknown[];
        status: number;
        message: string;
        count: number;
        total: number;
        totalResults: number;
    }>;
};
/**
 * Creates the receivingData resource methods (data-only versions)
 */
export declare function createReceivingDataResource(receiving: ReturnType<typeof createReceivingResource>): {
    list: (params?: ReceivingListParams) => Promise<z.objectInputType<{
        receivingUid: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough">[]>;
    get: (receivingUid: number | string) => Promise<{
        receivingUid: number;
    } & {
        [k: string]: unknown;
    }>;
    create: (receivingData: ReceivingCreateRequest) => Promise<{
        receivingUid: number;
    } & {
        [k: string]: unknown;
    }>;
    update: (receivingUid: number | string, updateData: ReceivingUpdateRequest) => Promise<{
        receivingUid: number;
    } & {
        [k: string]: unknown;
    }>;
    delete: (receivingUid: number | string) => Promise<{
        receivingUid: number;
    } & {
        [k: string]: unknown;
    }>;
};
export type ReceivingResource = ReturnType<typeof createReceivingResource>;
export type ReceivingDataResource = ReturnType<typeof createReceivingDataResource>;
export {};
//# sourceMappingURL=receiving.d.ts.map