@nubase/core 0.1.0 → 0.1.4

package/dist/index.d.mts

@@ -1,8 +1,44 @@
+import { z } from 'zod';
+
+interface HttpResponse<T = any> {
+    status: number;
+    data: T;
+}
+interface HttpRequestConfig {
+    headers?: Record<string, string>;
+    timeout?: number;
+    params?: Record<string, any>;
+}
+declare class HttpClient {
+    private baseUrl;
+    constructor({ baseUrl }: {
+        baseUrl?: string;
+    });
+    private request;
+    get<T>(url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+    post<T>(url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+    put<T>(url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+    patch<T>(url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+    delete<T>(url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+}
+
 interface SchemaMetadata<Output = any> {
     label?: string;
     description?: string;
     defaultValue?: Output;
+    /**
+     * Custom renderer identifier to override the default type-based rendering.
+     * Examples: "multiline", "email", "password", "url"
+     */
+    renderer?: string;
+    validateOnSubmit?: (value: any) => string | undefined;
+    validateOnSubmitAsync?: (value: any) => Promise<string | undefined>;
+    validateOnBlur?: (value: any) => string | undefined;
+    validateOnBlurAsync?: (value: any) => Promise<string | undefined>;
 }
+type ComputedSchemaMetadata<Output = any, Input = any> = {
+    [K in keyof SchemaMetadata<Output>]: (input: Input) => Promise<SchemaMetadata<Output>[K]>;
+};
 declare abstract class BaseSchema<Output = any> {
     /**
      * Phantom property used for TypeScript type inference.
@@ -10,30 +46,61 @@ declare abstract class BaseSchema<Output = any> {
      * @internal
      */
     readonly _outputType: Output;
+    /**
+     * The type identifier for this schema.
+     * Used for type-based form field rendering.
+     */
+    abstract readonly type: string;
     _meta: SchemaMetadata<Output>;
     /**
      * Replace the schema metadata with a new object.
      * @param meta The new metadata object.
      * @returns The schema instance for chaining.
      */
-    meta(meta: SchemaMetadata<Output>): this;
+    withMeta(meta: SchemaMetadata<Output>): this;
     /**
-     * Parses and validates the input data against the schema.
-     * Should throw an error if validation fails.
-     * @param data The data to parse.
-     * @returns The parsed data (potentially transformed).
+     * Add metadata with validation functions to the schema.
+     * @param meta The metadata object with validation functions.
+     * @returns The schema instance for chaining.
      */
-    abstract parse(data: any): Output;
+    withMetadata(meta: SchemaMetadata<Output>): this;
+    /**
+     * Makes this schema optional, allowing undefined values.
+     * @returns An OptionalSchema wrapping this schema.
+     */
+    optional(): OptionalSchema<this>;
+    /**
+     * Converts this nubase schema to a Zod schema.
+     * @returns The equivalent Zod schema.
+     */
+    abstract toZod(): z.ZodSchema<Output>;
 }
-
 declare class BooleanSchema extends BaseSchema<boolean> {
-    parse(data: any): boolean;
+    readonly type: "boolean";
+    toZod(): z.ZodBoolean;
 }
 declare class StringSchema extends BaseSchema<string> {
-    parse(data: any): string;
+    readonly type: "string";
+    toZod(): z.ZodString;
 }
 declare class NumberSchema extends BaseSchema<number> {
-    parse(data: any): number;
+    readonly type: "number";
+    toZod(): z.ZodNumber;
+}
+/**
+ * A wrapper schema that makes the wrapped schema optional.
+ * Allows undefined values in addition to the wrapped schema's type.
+ */
+declare class OptionalSchema<TWrapped extends BaseSchema<any>> extends BaseSchema<TWrapped["_outputType"] | undefined> {
+    readonly type: "optional";
+    _wrapped: TWrapped;
+    constructor(wrapped: TWrapped);
+    /**
+     * Get the underlying wrapped schema.
+     * @returns The wrapped schema.
+     */
+    unwrap(): TWrapped;
+    toZod(): z.ZodOptional<z.ZodNullable<z.ZodSchema<TWrapped["_outputType"]>>>;
 }
 /**
  * Type representing the shape of an object schema (key to schema mapping).
@@ -44,25 +111,356 @@ type ObjectShape = {
 /**
  * Infers the TypeScript output type from an ObjectShape.
  * Use mapped types to get the output type of each property schema.
+ * Required keys are those that are not OptionalSchema instances.
+ * Optional keys are those that are OptionalSchema instances.
  */
 type ObjectOutput<TShape extends ObjectShape> = {
-    [K in keyof TShape]: TShape[K]['_outputType'];
+    [K in keyof TShape as TShape[K] extends OptionalSchema<any> ? never : K]: TShape[K]["_outputType"];
+} & {
+    [K in keyof TShape as TShape[K] extends OptionalSchema<any> ? K : never]?: TShape[K]["_outputType"];
+};
+/**
+ * Type representing computed metadata for object properties.
+ */
+type ObjectComputedMetadata<TShape extends ObjectShape> = {
+    [K in keyof TShape]?: Partial<ComputedSchemaMetadata<TShape[K]["_outputType"], ObjectOutput<TShape>>>;
+};
+/**
+ * Represents a field within a layout group.
+ */
+interface FormLayoutField<TShape extends ObjectShape> {
+    /** The name of the field - must be a valid property key from the object shape */
+    name: keyof TShape;
+    /** Width of the field in grid units (1-12) - number of 1/12 spaces it occupies */
+    fieldWidth?: number;
+    /** Additional CSS classes for styling */
+    className?: string;
+    /** Whether the field should be hidden */
+    hidden?: boolean;
+}
+/**
+ * Represents a group of fields within a layout.
+ */
+interface LayoutGroup<TShape extends ObjectShape> {
+    /** Label for the group */
+    label?: string;
+    /** Description for the group */
+    description?: string;
+    /** Array of fields in this group */
+    fields: FormLayoutField<TShape>[];
+    /** Additional CSS classes for the group */
+    className?: string;
+    /** Whether the group should be collapsible */
+    collapsible?: boolean;
+    /** Whether the group is initially collapsed (if collapsible) */
+    defaultCollapsed?: boolean;
+}
+/**
+ * Represents a complete layout configuration.
+ */
+interface Layout<TShape extends ObjectShape> {
+    /** Type of layout */
+    type: "form" | "grid" | "tabs" | "accordion" | "custom" | "table";
+    /** Groups of fields within the layout */
+    groups: LayoutGroup<TShape>[];
+    /** Additional CSS classes for the layout */
+    className?: string;
+    /** Layout-specific configuration */
+    config?: {
+        /** Number of columns for grid layouts */
+        columns?: number;
+        /** Gap between elements */
+        gap?: string | number;
+        /** Other layout-specific options */
+        [key: string]: any;
+    };
+    /** Layout metadata - can contain any metadata, specific layouts may have specific metadata */
+    metadata?: Record<string, any>;
+}
+/**
+ * Form layout specific interface
+ */
+interface FormLayout<TShape extends ObjectShape> extends Layout<TShape> {
+    type: "form";
+    groups: LayoutGroup<TShape>[];
+}
+/**
+ * Table layout specific field
+ */
+interface TableLayoutField<TShape extends ObjectShape> {
+    /** The name of the field - must be a valid property key from the object shape */
+    name: keyof TShape;
+    /** Additional CSS classes for styling */
+    className?: string;
+    /** Whether the field should be hidden */
+    hidden?: boolean;
+    /** Column width in pixels - unlike fieldWidth, this is in pixels */
+    columnWidthPx?: number;
+    /** Whether the column should be pinned/frozen to the left */
+    pinned?: boolean;
+}
+/**
+ * Table layout specific interface
+ */
+interface TableLayout<TShape extends ObjectShape> extends Layout<TShape> {
+    type: "table";
+    /** For tables, we only have one group internally but expose fields directly */
+    groups: LayoutGroup<TShape>[];
+    /** Table-specific metadata */
+    metadata?: {
+        /** Fields that should be clickable links to view the entity */
+        linkFields?: (keyof TShape)[];
+        /** Other metadata */
+        [key: string]: any;
+    };
+}
+/**
+ * Type representing multiple layouts for an object schema.
+ */
+type ObjectLayouts<TShape extends ObjectShape> = {
+    [layoutName: string]: Layout<TShape>;
 };
-declare class ObjectSchema<TShape extends ObjectShape> extends BaseSchema<ObjectOutput<TShape>> {
+/**
+ * Type representing multiple form layouts
+ */
+type FormLayouts<TShape extends ObjectShape> = {
+    [layoutName: string]: FormLayout<TShape>;
+};
+/**
+ * Type representing multiple table layouts
+ */
+type TableLayouts<TShape extends ObjectShape> = {
+    [layoutName: string]: TableLayout<TShape>;
+};
+/**
+ * ObjectSchema with optional catchall.
+ *
+ * Note on typing: When using .catchall(), the output type remains ObjectOutput<TShape>.
+ * TypeScript cannot express "extra keys have type X" without conflicting with defined keys.
+ * The catchall provides runtime validation and passthrough behavior, but dynamic keys
+ * should be accessed via type assertion: `(data as any).dynamicKey` or `data["dynamicKey"]`.
+ */
+declare class ObjectSchema<TShape extends ObjectShape = any, TCatchall extends BaseSchema<any> | null = null> extends BaseSchema<ObjectOutput<TShape>> {
+    readonly type: "object";
     _shape: TShape;
-    constructor(shape: TShape);
-    parse(data: any): ObjectOutput<TShape>;
+    _computedMeta: ObjectComputedMetadata<TShape>;
+    _layouts: ObjectLayouts<TShape>;
+    _idField: keyof ObjectOutput<TShape>;
+    _catchall: TCatchall;
+    constructor(shape: TShape, catchall?: TCatchall);
+    /**
+     * Allow additional properties beyond the defined shape, validated against the provided schema.
+     * Similar to Zod's .catchall() method.
+     *
+     * @example
+     * const chartDataSchema = nu.object({ category: nu.string() }).catchall(nu.number());
+     * // Validates: { category: "Jan", desktop: 186, mobile: 80 }
+     *
+     * @param schema The schema to validate additional properties against.
+     * @returns A new ObjectSchema that allows additional properties.
+     */
+    catchall<TCatchallSchema extends BaseSchema<any>>(schema: TCatchallSchema): ObjectSchema<TShape, TCatchallSchema>;
+    /**
+     * Add computed metadata to the object schema.
+     * @param computedMeta Object mapping property keys to computed metadata functions.
+     * @returns The schema instance for chaining.
+     */
+    withComputed(computedMeta: ObjectComputedMetadata<TShape>): this;
+    /**
+     * Add layouts to the object schema.
+     * @param layouts Object mapping layout names to layout configurations.
+     * @returns The schema instance for chaining.
+     * @deprecated Use withFormLayouts or withTableLayouts instead
+     */
+    withLayouts(layouts: ObjectLayouts<TShape>): this;
+    /**
+     * Add form layouts to the object schema.
+     * @param layouts Object mapping layout names to form layout configurations.
+     * @returns The schema instance for chaining.
+     */
+    withFormLayouts(layouts: FormLayouts<TShape>): this;
+    /**
+     * Add table layouts to the object schema.
+     * @param layouts Object mapping layout names to table layout configurations with fields and optional linkFields.
+     * @returns The schema instance for chaining.
+     */
+    withTableLayouts(layouts: {
+        [layoutName: string]: {
+            fields: TableLayoutField<TShape>[];
+            className?: string;
+            config?: Layout<TShape>["config"];
+            metadata?: {
+                linkFields?: (keyof TShape)[];
+                [key: string]: any;
+            };
+        };
+    }): this;
+    /**
+     * Specify which field serves as the unique identifier for this object schema.
+     * This is used by resource operations to determine how to identify specific records.
+     * @param idField The field name or a selector function that returns the ID field.
+     * @returns The schema instance for chaining.
+     */
+    withId<K extends keyof ObjectOutput<TShape>>(idField: K | ((schema: ObjectOutput<TShape>) => ObjectOutput<TShape>[K])): this;
+    /**
+     * Get the ID field name for this object schema.
+     * @returns The field name that serves as the unique identifier.
+     */
+    getIdField(): keyof ObjectOutput<TShape>;
+    /**
+     * Get a specific layout by name.
+     * @param layoutName The name of the layout to retrieve.
+     * @returns The layout configuration or undefined if not found.
+     */
+    getLayout(layoutName: string): Layout<TShape> | undefined;
+    /**
+     * Get all available layout names.
+     * @returns Array of layout names.
+     */
+    getLayoutNames(): string[];
+    /**
+     * Check if a layout exists.
+     * @param layoutName The name of the layout to check.
+     * @returns True if the layout exists, false otherwise.
+     */
+    hasLayout(layoutName: string): boolean;
+    /**
+     * Get the computed metadata for a specific property.
+     * @param key The property key.
+     * @param data The parsed object data to pass to computed functions.
+     * @returns Promise resolving to the computed metadata.
+     */
+    getComputedMeta(key: keyof TShape, data: ObjectOutput<TShape>): Promise<Partial<SchemaMetadata<TShape[typeof key]["_outputType"]>>>;
+    /**
+     * Get all computed metadata for all properties.
+     * @param data The parsed object data to pass to computed functions.
+     * @returns Promise resolving to a map of property keys to computed metadata.
+     */
+    getAllComputedMeta(data: ObjectOutput<TShape>): Promise<Record<keyof TShape, Partial<SchemaMetadata<any>>>>;
+    /**
+     * Get merged metadata (static + computed) for all properties.
+     * @param data The current form data to pass to computed functions.
+     * @returns Promise resolving to a map of property keys to merged metadata.
+     */
+    getAllMergedMeta(data: Partial<ObjectOutput<TShape>>): Promise<Record<keyof TShape, SchemaMetadata<any>>>;
+    /**
+     * Create a new ObjectSchema with certain properties omitted.
+     * @param keys The property keys to omit from the schema.
+     * @returns A new ObjectSchema without the specified properties.
+     */
+    omit<K extends keyof TShape>(...keys: K[]): ObjectSchema<Omit<TShape, K>>;
+    /**
+     * Create a new ObjectSchema with additional or modified properties.
+     * @param shape The new properties to add or existing properties to modify.
+     * @returns A new ObjectSchema with the extended shape.
+     */
+    extend<TExtend extends ObjectShape>(shape: TExtend): ObjectSchema<TShape & TExtend>;
+    /**
+     * Create a new ObjectSchema where all top-level properties become optional.
+     * This wraps each field in an OptionalSchema, similar to how Zod handles partial.
+     * @returns A new ObjectSchema where all properties are optional.
+     */
+    partial(): ObjectSchema<{
+        [K in keyof TShape]: OptionalSchema<TShape[K]>;
+    }>;
+    toZod(): z.ZodSchema<ObjectOutput<TShape>>;
+    /**
+     * Returns a Zod schema with URL coercion enabled.
+     * This automatically converts string values from URL parameters to the expected types:
+     * - "37" → 37 (number)
+     * - "true" → true (boolean)
+     * - "hello" → "hello" (string, unchanged)
+     *
+     * Use this when parsing URL search params that arrive as strings but need to be typed.
+     *
+     * @returns A Zod schema with coercion for URL parameter parsing
+     */
+    toZodWithCoercion(): z.ZodSchema<ObjectOutput<TShape>>;
 }
 /**
  * Infers the TypeScript output type from an element schema for an array.
  */
-type ArrayOutput<TElementSchema extends BaseSchema<any>> = Array<TElementSchema['_outputType']>;
+type ArrayOutput<TElementSchema extends BaseSchema<any>> = Array<TElementSchema["_outputType"]>;
 declare class ArraySchema<TElementSchema extends BaseSchema<any>> extends BaseSchema<ArrayOutput<TElementSchema>> {
+    readonly type: "array";
     _element: TElementSchema;
     constructor(elementSchema: TElementSchema);
-    parse(data: any): ArrayOutput<TElementSchema>;
+    toZod(): z.ZodArray<z.ZodSchema<TElementSchema["_outputType"]>>;
+}
+/**
+ * RecordSchema represents a dictionary/map type with string keys and values of a specific type.
+ * Similar to TypeScript's Record<string, T> or Zod's z.record().
+ *
+ * @example
+ * const scoresSchema = nu.record(nu.number());
+ * // Represents: { [key: string]: number }
+ */
+declare class RecordSchema<TValueSchema extends BaseSchema<any>> extends BaseSchema<Record<string, TValueSchema["_outputType"]>> {
+    readonly type: "record";
+    _valueSchema: TValueSchema;
+    constructor(valueSchema: TValueSchema);
+    toZod(): z.ZodRecord<z.ZodString, z.ZodSchema<TValueSchema["_outputType"]>>;
+}
+/**
+ * Infers the TypeScript type from a schema.
+ * @example
+ * const userSchema = nu.object({ name: nu.string() });
+ * type User = Infer&lt;typeof userSchema&gt;; // { name: string }
+ */
+type Infer<T extends BaseSchema<any>> = T["_outputType"];
+type NuSchema = BooleanSchema | StringSchema | NumberSchema | OptionalSchema<any> | ObjectSchema<any> | ArraySchema<any> | RecordSchema<any>;
+
+declare const emptySchema: ObjectSchema<{}, null>;
+declare const idNumberSchema: ObjectSchema<{
+    id: NumberSchema;
+}, null>;
+declare const idStringSchema: ObjectSchema<{
+    id: StringSchema;
+}, null>;
+declare const successSchema: ObjectSchema<{
+    success: BooleanSchema;
+}, null>;
+declare const successMessageSchema: ObjectSchema<{
+    success: BooleanSchema;
+    message: OptionalSchema<StringSchema>;
+}, null>;
+declare const successErrorSchema: ObjectSchema<{
+    success: BooleanSchema;
+    message: OptionalSchema<StringSchema>;
+    errors: OptionalSchema<ArraySchema<ObjectSchema<{
+        field: OptionalSchema<StringSchema>;
+        message: StringSchema;
+    }, null>>>;
+}, null>;
+
+declare const errorSchema: ObjectSchema<{
+    errorCode: StringSchema;
+    errorMessage: StringSchema;
+}, null>;
+
+/**
+ * Represents a validation error in Nubase schema validation
+ */
+interface NubaseValidationError {
+    path: string;
+    message: string;
+    value?: unknown;
+}
+/**
+ * Error thrown when Nubase schema validation fails
+ */
+declare class NubaseSchemaError extends Error {
+    readonly errors: NubaseValidationError[];
+    constructor(errors: NubaseValidationError[]);
+    /**
+     * Creates a NubaseSchemaError from a list of error messages
+     */
+    static fromMessages(errorMessages: string[]): NubaseSchemaError;
+    /**
+     * Type guard to check if an error is a NubaseSchemaError
+     */
+    static isNubaseSchemaError(error: unknown): error is NubaseSchemaError;
 }
-type NuSchema = BooleanSchema | StringSchema | NumberSchema | ObjectSchema<any> | ArraySchema<any>;
 
 /**
  * The main nubase schema instance.
@@ -82,12 +480,253 @@ declare const nu: {
      * Creates an object schema with a defined shape.
      * @param shape An object mapping keys to schemas.
      */
-    object: <TShape extends ObjectShape>(shape: TShape) => ObjectSchema<TShape>;
+    object: <TShape extends ObjectShape>(shape: TShape) => ObjectSchema<TShape, null>;
     /**
      * Creates an array schema with a defined element schema.
      * @param elementSchema The schema for elements within the array.
      */
     array: <TElementSchema extends BaseSchema<any>>(elementSchema: TElementSchema) => ArraySchema<TElementSchema>;
+    /**
+     * Creates a record schema (dictionary) with string keys and values of a specific type.
+     * Similar to TypeScript's Record<string, T>.
+     *
+     * @example
+     * const scoresSchema = nu.record(nu.number());
+     * // Represents: { [key: string]: number }
+     *
+     * @param valueSchema The schema for values in the record.
+     */
+    record: <TValueSchema extends BaseSchema<any>>(valueSchema: TValueSchema) => RecordSchema<TValueSchema>;
 };
 
-export { type ArrayOutput, ArraySchema, BaseSchema, BooleanSchema, type NuSchema, NumberSchema, type ObjectOutput, ObjectSchema, type ObjectShape, type SchemaMetadata, StringSchema, nu };
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+interface RequestSchema {
+    method: HttpMethod;
+    path: string;
+    requestParams: ObjectSchema;
+    requestBody?: ObjectSchema;
+    responseBody: ObjectSchema | any;
+}
+type InferRequestParams<T extends RequestSchema> = Infer<T["requestParams"]>;
+type InferRequestBody<T extends RequestSchema> = T["requestBody"] extends ObjectSchema ? Infer<T["requestBody"]> : undefined;
+type InferResponseBody<T extends RequestSchema> = Infer<T["responseBody"]>;
+
+/**
+ * Configuration for series charts.
+ * Defines which data keys represent the series and their display properties.
+ */
+declare const seriesConfigSchema: ObjectSchema<{
+    /** The data key field names that represent numeric series (e.g., ["desktop", "mobile"]) */
+    keys: ArraySchema<StringSchema>;
+    /** Optional labels for each key (e.g., { desktop: "Desktop Users" }) */
+    labels: OptionalSchema<ObjectSchema<{}, null>>;
+    /** Optional colors for each key (e.g., { desktop: "var(--chart1)" }) */
+    colors: OptionalSchema<ObjectSchema<{}, null>>;
+}, null>;
+/**
+ * A single data point in a series chart.
+ * The 'category' is the x-axis label (e.g., "January", "Q1", "2024-01").
+ * Additional numeric fields are the data series values (e.g., desktop: 186, mobile: 80).
+ *
+ * Uses .catchall(nu.number()) to allow dynamic numeric fields beyond 'category'.
+ */
+declare const seriesDataPointSchema: ObjectSchema<{
+    category: StringSchema;
+}, NumberSchema>;
+/**
+ * Complete series data response from an endpoint.
+ * Used for Line, Bar, and Area charts.
+ */
+declare const seriesDataSchema: ObjectSchema<{
+    type: StringSchema;
+    config: ObjectSchema<{
+        /** The data key field names that represent numeric series (e.g., ["desktop", "mobile"]) */
+        keys: ArraySchema<StringSchema>;
+        /** Optional labels for each key (e.g., { desktop: "Desktop Users" }) */
+        labels: OptionalSchema<ObjectSchema<{}, null>>;
+        /** Optional colors for each key (e.g., { desktop: "var(--chart1)" }) */
+        colors: OptionalSchema<ObjectSchema<{}, null>>;
+    }, null>;
+    data: ArraySchema<ObjectSchema<{
+        category: StringSchema;
+    }, NumberSchema>>;
+}, null>;
+type SeriesConfig = Infer<typeof seriesConfigSchema>;
+type SeriesDataPoint = Infer<typeof seriesDataPointSchema> & Record<string, number>;
+type SeriesData = {
+    type: "series";
+    config: SeriesConfig;
+    data: SeriesDataPoint[];
+};
+/**
+ * A single segment in a proportional chart.
+ * Note: Colors are automatically assigned by the frontend based on index.
+ */
+declare const proportionalDataItemSchema: ObjectSchema<{
+    label: StringSchema;
+    value: NumberSchema;
+}, null>;
+/**
+ * Complete proportional data response from an endpoint.
+ * Used for Pie and Donut charts.
+ */
+declare const proportionalDataSchema: ObjectSchema<{
+    type: StringSchema;
+    data: ArraySchema<ObjectSchema<{
+        label: StringSchema;
+        value: NumberSchema;
+    }, null>>;
+}, null>;
+type ProportionalDataItem = Infer<typeof proportionalDataItemSchema>;
+type ProportionalData = {
+    type: "proportional";
+    data: Array<ProportionalDataItem & {
+        fill?: string;
+    }>;
+};
+/**
+ * KPI/stat widget data for displaying a single metric.
+ */
+declare const kpiDataSchema: ObjectSchema<{
+    type: StringSchema;
+    value: StringSchema;
+    label: OptionalSchema<StringSchema>;
+    trend: OptionalSchema<StringSchema>;
+    trendDirection: OptionalSchema<StringSchema>;
+}, null>;
+type KpiData = {
+    type: "kpi";
+    value: string;
+    label?: string;
+    trend?: string;
+    trendDirection?: "up" | "down" | "neutral";
+};
+/**
+ * Column definition for table widgets.
+ */
+declare const tableColumnSchema: ObjectSchema<{
+    key: StringSchema;
+    label: StringSchema;
+    width: OptionalSchema<StringSchema>;
+}, null>;
+/**
+ * Complete table data response from an endpoint.
+ */
+declare const tableDataSchema: ObjectSchema<{
+    type: StringSchema;
+    columns: ArraySchema<ObjectSchema<{
+        key: StringSchema;
+        label: StringSchema;
+        width: OptionalSchema<StringSchema>;
+    }, null>>;
+    rows: ArraySchema<ObjectSchema<{}, null>>;
+}, null>;
+type TableColumn = Infer<typeof tableColumnSchema>;
+type TableData = {
+    type: "table";
+    columns: TableColumn[];
+    rows: Record<string, unknown>[];
+};
+/**
+ * Union of all possible widget data types.
+ */
+type WidgetData = SeriesData | ProportionalData | KpiData | TableData;
+/**
+ * Widget data type discriminator.
+ */
+type WidgetDataType = "series" | "proportional" | "kpi" | "table";
+
+/**
+ * Type for a series widget endpoint that preserves the responseBody type.
+ */
+type SeriesWidgetRequestSchema = {
+    method: "GET";
+    path: string;
+    requestParams: ObjectSchema<any>;
+    responseBody: typeof seriesDataSchema;
+};
+/**
+ * Type for a proportional widget endpoint that preserves the responseBody type.
+ */
+type ProportionalWidgetRequestSchema = {
+    method: "GET";
+    path: string;
+    requestParams: ObjectSchema<any>;
+    responseBody: typeof proportionalDataSchema;
+};
+/**
+ * Type for a KPI widget endpoint that preserves the responseBody type.
+ */
+type KpiWidgetRequestSchema = {
+    method: "GET";
+    path: string;
+    requestParams: ObjectSchema<any>;
+    responseBody: typeof kpiDataSchema;
+};
+/**
+ * Type for a table widget endpoint that preserves the responseBody type.
+ */
+type TableWidgetRequestSchema = {
+    method: "GET";
+    path: string;
+    requestParams: ObjectSchema<any>;
+    responseBody: typeof tableDataSchema;
+};
+/**
+ * Creates a RequestSchema for a Series widget endpoint.
+ * The response conforms to SeriesData shape.
+ *
+ * @param path The API endpoint path (e.g., "/dashboard/revenue")
+ * @param requestParams Optional request parameters schema
+ * @returns A RequestSchema configured for series data
+ *
+ * @example
+ * ```typescript
+ * export const getRevenueChartSchema = createSeriesWidgetEndpoint("/dashboard/revenue");
+ * ```
+ */
+declare function createSeriesWidgetEndpoint(path: string, requestParams?: ObjectSchema<any>): SeriesWidgetRequestSchema;
+/**
+ * Creates a RequestSchema for a Proportional widget endpoint.
+ * The response conforms to ProportionalData shape.
+ *
+ * @param path The API endpoint path (e.g., "/dashboard/browser-stats")
+ * @param requestParams Optional request parameters schema
+ * @returns A RequestSchema configured for proportional data
+ *
+ * @example
+ * ```typescript
+ * export const getBrowserStatsSchema = createProportionalWidgetEndpoint("/dashboard/browsers");
+ * ```
+ */
+declare function createProportionalWidgetEndpoint(path: string, requestParams?: ObjectSchema<any>): ProportionalWidgetRequestSchema;
+/**
+ * Creates a RequestSchema for a KPI widget endpoint.
+ * The response conforms to KpiData shape.
+ *
+ * @param path The API endpoint path (e.g., "/dashboard/total-revenue")
+ * @param requestParams Optional request parameters schema
+ * @returns A RequestSchema configured for KPI data
+ *
+ * @example
+ * ```typescript
+ * export const getTotalRevenueSchema = createKpiWidgetEndpoint("/dashboard/total-revenue");
+ * ```
+ */
+declare function createKpiWidgetEndpoint(path: string, requestParams?: ObjectSchema<any>): KpiWidgetRequestSchema;
+/**
+ * Creates a RequestSchema for a Table widget endpoint.
+ * The response conforms to TableData shape.
+ *
+ * @param path The API endpoint path (e.g., "/dashboard/recent-orders")
+ * @param requestParams Optional request parameters schema
+ * @returns A RequestSchema configured for table data
+ *
+ * @example
+ * ```typescript
+ * export const getRecentOrdersSchema = createTableWidgetEndpoint("/dashboard/orders");
+ * ```
+ */
+declare function createTableWidgetEndpoint(path: string, requestParams?: ObjectSchema<any>): TableWidgetRequestSchema;
+
+export { type ArrayOutput, ArraySchema, BaseSchema, BooleanSchema, type ComputedSchemaMetadata, type FormLayout, type FormLayoutField, type FormLayouts, HttpClient, type HttpMethod, type HttpRequestConfig, type HttpResponse, type Infer, type InferRequestBody, type InferRequestParams, type InferResponseBody, type KpiData, type KpiWidgetRequestSchema, type Layout, type LayoutGroup, type NuSchema, NubaseSchemaError, type NubaseValidationError, NumberSchema, type ObjectComputedMetadata, type ObjectLayouts, type ObjectOutput, ObjectSchema, type ObjectShape, OptionalSchema, type ProportionalData, type ProportionalDataItem, type ProportionalWidgetRequestSchema, RecordSchema, type RequestSchema, type SchemaMetadata, type SeriesConfig, type SeriesData, type SeriesDataPoint, type SeriesWidgetRequestSchema, StringSchema, type TableColumn, type TableData, type TableLayout, type TableLayoutField, type TableLayouts, type TableWidgetRequestSchema, type WidgetData, type WidgetDataType, createKpiWidgetEndpoint, createProportionalWidgetEndpoint, createSeriesWidgetEndpoint, createTableWidgetEndpoint, emptySchema, errorSchema, idNumberSchema, idStringSchema, kpiDataSchema, nu, proportionalDataItemSchema, proportionalDataSchema, seriesConfigSchema, seriesDataPointSchema, seriesDataSchema, successErrorSchema, successMessageSchema, successSchema, tableColumnSchema, tableDataSchema };