@ritas-inc/hanaqueryapi-client/dist/types.d.ts

TypeScript client for HANA Query API with full type safety and error handling

/**
 * HANA Query API Client - Type Definitions
 *
 * Complete TypeScript interfaces matching the current API response structures.
 * These types are based on the actual API implementation and ensure type safety.
 */
/**
 * Base API response structure
 */
export interface BaseAPIResponse {
    success: boolean;
}
/**
 * Successful API response
 */
export interface SuccessResponse<TData = any, TMetadata = any> extends BaseAPIResponse {
    success: true;
    data: TData;
    metadata?: TMetadata;
}
/**
 * Error API response
 */
export interface ErrorResponse extends BaseAPIResponse {
    success: false;
    problem: ProblemDetails;
}
/**
 * Generic API response (success or error)
 */
export type APIResponse<TData = any, TMetadata = any> = SuccessResponse<TData, TMetadata> | ErrorResponse;
/**
 * Problem details for error responses (RFC 7807)
 */
export interface ProblemDetails {
    status: number;
    type: string;
    title: string;
    detail: string;
    instance: string;
    context: {
        request: string;
        responseText: string;
    };
    issues: string[];
}
/**
 * Date range parameters for sales endpoint
 */
export interface SalesParams {
    from: string;
    to: string;
}
/**
 * Generic request options
 */
export interface RequestOptions {
    timeout?: number;
    retries?: number;
    signal?: AbortSignal;
}
/**
 * API response headers
 */
export interface APIResponseHeaders {
    'x-response-time'?: string;
    'x-authorization-response'?: 'ok' | 'unauthorized';
    'content-type'?: string;
}
/**
 * Health check response data
 */
export interface HealthData {
    status: 'ok';
    timestamp: string;
    uptime: number;
}
/**
 * Health endpoint metadata containing system information
 *
 * @example
 * ```typescript
 * {
 *   systemInfo: true,
 *   serverTime: "2025-06-30T12:00:00.000Z",
 *   nodeVersion: "v24.0.2",
 *   platform: "linux",
 *   arch: "x64"
 * }
 * ```
 */
export interface HealthMetadata {
    /** Indicates that system information is included in the metadata */
    systemInfo: boolean;
    /** Server current time in ISO 8601 format */
    serverTime: string;
    /** Node.js version (e.g., "v24.0.2") */
    nodeVersion: string;
    /** Operating system platform (e.g., "linux", "darwin", "win32") */
    platform: string;
    /** System architecture (e.g., "x64", "arm64") */
    arch: string;
}
/**
 * Health endpoint response
 */
export type HealthResponse = SuccessResponse<HealthData, HealthMetadata>;
/**
 * API documentation response data
 */
export interface DocsData {
    name: string;
    version: string;
    endpoints: Record<string, string>;
}
/**
 * Documentation endpoint metadata containing API information
 *
 * @example
 * ```typescript
 * {
 *   endpointCount: 9,
 *   apiVersion: "v1",
 *   generatedAt: "2025-06-30T12:00:00.000Z",
 *   documentation: true
 * }
 * ```
 */
export interface DocsMetadata {
    /** Total number of available API endpoints */
    endpointCount: number;
    /** API version identifier (e.g., "v1") */
    apiVersion: string;
    /** Documentation generation timestamp in ISO 8601 format */
    generatedAt: string;
    /** Indicates this is a documentation endpoint response */
    documentation: boolean;
}
/**
 * Documentation endpoint response
 */
export type DocsResponse = SuccessResponse<DocsData, DocsMetadata>;
/**
 * Individual item status
 */
export interface ItemStatus {
    itemgroup: string;
    itemcode: string;
    description: string;
    onhand: number;
    onorder: number;
    onassembly: number;
    min: number;
    max: number;
}
/**
 * Individual sales order item
 */
export interface SalesItem {
    orderEntry: number;
    orderNum: number;
    cardName: string;
    dueDate: string;
    itemcode: string;
    openqty: number;
}
/**
 * Items response data
 */
export interface ItemsStatusData {
    items: ItemStatus[];
}
/**
 * Sales response data
 */
export interface SalesData {
    sales: SalesItem[];
}
/**
 * Individual item group
 */
export interface ItemGroup {
    code: string;
    name: string;
}
/**
 * Item groups response data
 */
export interface ItemGroupsData {
    groups: ItemGroup[];
}
/**
 * Items metadata
 */
export interface ItemsStatusMetadata {
    count: number;
}
/**
 * Sales metadata
 */
export interface SalesMetadata {
    count: number;
    from: string;
    to: string;
}
/**
 * Item groups metadata
 */
export interface ItemGroupsMetadata {
    count: number;
}
/**
 * Items endpoint response
 */
export type ItemsStatusResponse = SuccessResponse<ItemsStatusData, ItemsStatusMetadata>;
/**
 * Sales endpoint response
 */
export type SalesResponse = SuccessResponse<SalesData, SalesMetadata>;
/**
 * Item groups endpoint response
 */
export type ItemGroupsResponse = SuccessResponse<ItemGroupsData, ItemGroupsMetadata>;
/**
 * Individual item hierarchy
 */
export interface Hierarchy {
    rank: string;
    root: string;
    parent: string | null;
    node: string;
    quantity: number;
    injections: number;
}
/**
 * Item hierarchies response data
 */
export interface HierarchiesData {
    hierarchies: Hierarchy[];
}
/**
 * Item hierarchies metadata
 */
export interface HierarchiesMetadata {
    count: number;
}
/**
 * Item hierarchies endpoint response
 */
export type HierarchiesResponse = SuccessResponse<HierarchiesData, HierarchiesMetadata>;
/**
 * Individual tree relationship
 */
export interface Tree {
    parent: string;
    itemcode: string;
    quantity: number;
    injPerUn?: number;
    parentSector?: string;
    itemSector?: string;
    parentMaxPerOrder?: number;
    itemMaxPerOrder?: number;
}
/**
 * Trees response data
 */
export interface TreesData {
    trees: Tree[];
}
/**
 * Trees metadata
 */
export interface TreesMetadata {
    count: number;
}
/**
 * Trees endpoint response
 */
export type TreesResponse = SuccessResponse<TreesData, TreesMetadata>;
/**
 * Individual production sector
 */
export interface ProductionSector {
    code: string;
    name: string;
    order: number;
}
/**
 * Production sectors response data
 */
export interface ProductionSectorsData {
    sectors: ProductionSector[];
}
/**
 * Production sectors metadata
 */
export interface ProductionSectorsMetadata {
    count: number;
    lastUpdated: string;
}
/**
 * Production sectors endpoint response
 */
export type ProductionSectorsResponse = SuccessResponse<ProductionSectorsData, ProductionSectorsMetadata>;
/**
 * Production plan
 */
export interface Plan {
    plan_id: number;
    plan_createdate: string;
    plan_username: string;
    plan_sapstatus: string;
    plan_status: string;
    plan_releasedate: string | null;
    products_total: number;
    products_generated: number;
    products_canceled: number;
    products_released: number;
    products_closed: number;
    injections_generated: number;
    injections_canceled: number;
    injections_released: number;
    injections_closed: number;
}
/**
 * Plans list response data
 */
export interface PlansData {
    plans: Plan[];
}
/**
 * Plans list metadata
 */
export interface PlansMetadata {
    count: number;
}
/**
 * Plans list endpoint response
 */
export type PlansResponse = SuccessResponse<PlansData, PlansMetadata>;
/**
 * Single plan response data
 */
export interface SinglePlanData {
    plan: Plan;
}
/**
 * Single plan metadata
 */
export interface SinglePlanMetadata {
    planId: number;
}
/**
 * Single plan endpoint response
 */
export type SinglePlanResponse = SuccessResponse<SinglePlanData, SinglePlanMetadata>;
/**
 * Plan product
 */
export interface PlanProduct {
    itemcode: string;
    quantity: number;
    group: string;
}
/**
 * Plan products response data
 *
 * @remarks
 * The products array can be empty when a plan exists but has no products.
 * This is a normal, successful response (HTTP 200), not an error condition.
 */
export interface PlanProductsData {
    products: PlanProduct[];
}
/**
 * Plan products metadata
 */
export interface PlanProductsMetadata {
    count: number;
    planId: number;
}
/**
 * Plan products endpoint response
 *
 * @remarks
 * API Behavior:
 * - HTTP 200: Plan exists (products array may be empty or populated)
 * - HTTP 404: Plan with the specified ID does not exist
 * - Empty products array indicates the plan exists but has no products
 */
export type PlanProductsResponse = SuccessResponse<PlanProductsData, PlanProductsMetadata>;
/**
 * Work order
 */
export interface WorkOrder {
    order_id: number;
    order_num: number;
    order_itemcode: string;
    order_plannedqty: number;
    order_status: string;
    order_completedqty: number;
    order_rejectqty: number;
    order_createdate: string;
    order_originabs: number | null;
    order_originnum: number | null;
    order_releasedate: string | null;
}
/**
 * Plan work orders response data
 *
 * @remarks
 * The workOrders array can be empty when a plan exists but has no work orders.
 * This is a normal, successful response (HTTP 200), not an error condition.
 */
export interface PlanWorkOrdersData {
    workOrders: WorkOrder[];
}
/**
 * Plan work orders metadata
 */
export interface PlanWorkOrdersMetadata {
    count: number;
    planId: number;
}
/**
 * Plan work orders endpoint response
 *
 * @remarks
 * API Behavior:
 * - HTTP 200: Plan exists (workOrders array may be empty or populated)
 * - HTTP 404: Plan with the specified ID does not exist
 * - Empty workOrders array indicates the plan exists but has no work orders
 */
export type PlanWorkOrdersResponse = SuccessResponse<PlanWorkOrdersData, PlanWorkOrdersMetadata>;
/**
 * Plan sector summary
 */
export interface PlanSectorSummary {
    plan_entry: number;
    sector_name: string;
    sector_planned_qtty: number;
    sector_open_qtty: number;
    sector_completed_qtty: number;
    sector_abandoned_qtty: number;
}
/**
 * Single plan sectors summary response data
 */
export interface PlanSectorsSummaryData {
    sectors: PlanSectorSummary[];
}
/**
 * Single plan sectors summary metadata
 */
export interface PlanSectorsSummaryMetadata {
    plan_id: number;
    sector_count: number;
    total_planned: number;
    total_completed: number;
    completion_rate: number;
}
/**
 * Single plan sectors summary endpoint response
 *
 * @remarks
 * API Behavior:
 * - HTTP 200: Plan exists (sectors array may be empty or populated)
 * - HTTP 404: Plan with the specified ID does not exist
 * - Empty sectors array indicates the plan exists but has no sectors
 */
export type PlanSectorsSummaryResponse = SuccessResponse<PlanSectorsSummaryData, PlanSectorsSummaryMetadata>;
/**
 * All plans sectors summary response data
 */
export interface AllPlansSectorsSummaryData {
    sectors: PlanSectorSummary[];
}
/**
 * All plans sectors summary metadata
 */
export interface AllPlansSectorsSummaryMetadata {
    total_sectors: number;
    unique_plans: number;
    unique_sector_names: string[];
    total_planned: number;
    total_completed: number;
    overall_completion_rate: number;
}
/**
 * All plans sectors summary endpoint response
 */
export type AllPlansSectorsSummaryResponse = SuccessResponse<AllPlansSectorsSummaryData, AllPlansSectorsSummaryMetadata>;
/**
 * User lookup response data
 */
export interface UserData {
    userId: number;
}
/**
 * User lookup metadata
 */
export interface UserMetadata {
    username: string;
}
/**
 * User lookup endpoint response
 */
export type UserResponse = SuccessResponse<UserData, UserMetadata>;
/**
 * Client configuration options
 */
export interface ClientConfig {
    baseUrl: string;
    timeout?: number;
    retries?: number;
    retryDelay?: number;
    enableLogging?: boolean;
    logLevel?: 'debug' | 'info' | 'warn' | 'error';
    headers?: Record<string, string>;
}
/**
 * Request context for logging/debugging
 */
export interface RequestContext {
    method: string;
    url: string;
    startTime: number;
    endTime?: number;
    duration?: number;
    attempt?: number;
    maxAttempts?: number;
}
/**
 * Client error types
 */
export type ClientErrorType = 'network_error' | 'timeout_error' | 'validation_error' | 'authorization_error' | 'not_found_error' | 'server_error' | 'unknown_error';
/**
 * Client error details
 */
export interface ClientErrorDetails {
    type: ClientErrorType;
    message: string;
    statusCode?: number;
    originalError?: Error;
    context?: RequestContext;
    problemDetails?: ProblemDetails;
}
/**
 * Extract data type from API response
 */
export type ExtractData<T> = T extends SuccessResponse<infer TData, any> ? TData : never;
/**
 * Extract metadata type from API response
 */
export type ExtractMetadata<T> = T extends SuccessResponse<any, infer TMetadata> ? TMetadata : never;
/**
 * Type guard for success responses
 */
export declare function isSuccessResponse<T, M>(response: APIResponse<T, M>): response is SuccessResponse<T, M>;
/**
 * Type guard for error responses
 */
export declare function isErrorResponse(response: APIResponse): response is ErrorResponse;
/**
 * Client method return types - all methods return consistent { data, metadata } format
 *
 * @example
 * ```typescript
 * // All client methods return the same structure:
 * const healthResult: ClientHealthResult = await client.getHealth();
 * const { data, metadata } = healthResult;
 *
 * // Consistent destructuring pattern for all methods:
 * const { data: healthData, metadata: healthMeta } = await client.getHealth();
 * const { data: docsData, metadata: docsMeta } = await client.getDocs();
 * const { data: itemsData, metadata: itemsMeta } = await client.getItemsStatus();
 * ```
 */
export type ClientHealthResult = {
    data: HealthData;
    metadata: HealthMetadata;
};
export type ClientDocsResult = {
    data: DocsData;
    metadata: DocsMetadata;
};
export type ClientItemsStatusResult = {
    data: ItemsStatusData;
    metadata: ItemsStatusMetadata;
};
export type ClientHierarchiesResult = {
    data: HierarchiesData;
    metadata: HierarchiesMetadata;
};
export type ClientTreesResult = {
    data: TreesData;
    metadata: TreesMetadata;
};
export type ClientProductionSectorsResult = {
    data: ProductionSectorsData;
    metadata: ProductionSectorsMetadata;
};
export type ClientPlansResult = {
    data: PlansData;
    metadata: PlansMetadata;
};
export type ClientSinglePlanResult = {
    data: SinglePlanData;
    metadata: SinglePlanMetadata;
};
export type ClientPlanProductsResult = {
    data: PlanProductsData;
    metadata: PlanProductsMetadata;
};
export type ClientPlanWorkOrdersResult = {
    data: PlanWorkOrdersData;
    metadata: PlanWorkOrdersMetadata;
};
export type ClientUserResult = {
    data: UserData;
    metadata: UserMetadata;
};
/**
 * Map of all available endpoints and their response types
 */
export interface EndpointMap {
    'GET /health': HealthResponse;
    'GET /docs': DocsResponse;
    'GET /items/status': ItemsStatusResponse;
    'GET /items/hierarchies': HierarchiesResponse;
    'GET /items/trees': TreesResponse;
    'GET /production-sectors': ProductionSectorsResponse;
    'GET /plans': PlansResponse;
    'GET /plans/{planId}': SinglePlanResponse;
    'GET /plans/{planId}/products': PlanProductsResponse;
    'GET /plans/{planId}/work-orders': PlanWorkOrdersResponse;
    'GET /users/{username}': UserResponse;
}
/**
 * Map of client method return types
 */
export interface ClientEndpointMap {
    'getHealth': ClientHealthResult;
    'getDocs': ClientDocsResult;
    'getItemsStatus': ClientItemsStatusResult;
    'getItemHierarchies': ClientHierarchiesResult;
    'getItemTrees': ClientTreesResult;
    'getProductionSectors': ClientProductionSectorsResult;
    'getPlans': ClientPlansResult;
    'getPlan': ClientSinglePlanResult;
    'getPlanProducts': ClientPlanProductsResult;
    'getPlanWorkOrders': ClientPlanWorkOrdersResult;
    'getUser': ClientUserResult;
}
/**
 * Union of all possible API responses
 */
export type AnyAPIResponse = EndpointMap[keyof EndpointMap];
/**
 * Union of all possible client method results
 */
export type AnyClientResult = ClientEndpointMap[keyof ClientEndpointMap];
//# sourceMappingURL=types.d.ts.map