@objectql/types 1.8.3 → 1.9.0

package/dist/formula.d.ts

@@ -0,0 +1,308 @@
+/**
+ * Formula Engine Types
+ *
+ * Type definitions for the ObjectQL Formula Engine.
+ * Formulas are read-only calculated fields that derive values from other fields,
+ * related records, or system variables using JavaScript-style expressions.
+ *
+ * @see docs/spec/formula.md for complete specification
+ */
+import { ObjectQLError } from './api';
+/**
+ * Data types that formula expressions can return
+ */
+export type FormulaDataType = 'number' | 'text' | 'date' | 'datetime' | 'boolean' | 'currency' | 'percent';
+/**
+ * Valid formula return values based on data type
+ */
+export type FormulaValue = number | string | boolean | Date | null | undefined;
+/**
+ * Valid field values that can be used in formula expressions
+ */
+export type FormulaFieldValue = string | number | boolean | Date | null | undefined | FormulaFieldValue[] | {
+    [key: string]: FormulaFieldValue;
+};
+/**
+ * Configuration for a formula field
+ *
+ * Formula fields are defined in object metadata and evaluated at query time.
+ * They are never stored in the database.
+ */
+export interface FormulaFieldConfig {
+    /** Field type - must be 'formula' */
+    type: 'formula';
+    /** JavaScript expression to evaluate */
+    expression: string;
+    /** Expected return data type of the expression */
+    data_type: FormulaDataType;
+    /** Display label for UI */
+    label?: string;
+    /** Help text explaining the formula's purpose */
+    description?: string;
+    /** Display format for numbers/dates (e.g., "0.00", "YYYY-MM-DD") */
+    format?: string;
+    /** Decimal precision for numeric results */
+    precision?: number;
+    /** Treat blank/null as zero in calculations (default: false) */
+    blank_as_zero?: boolean;
+    /** Default value to use when referenced fields are null/undefined */
+    treat_blank_as?: FormulaValue;
+    /** AI-friendly context for understanding business intent */
+    ai_context?: FormulaAiContext;
+}
+/**
+ * AI context for formula fields
+ *
+ * Provides semantic information to help AI tools understand the
+ * business purpose and validation requirements of the formula.
+ */
+export interface FormulaAiContext {
+    /** Business intent behind the formula */
+    intent?: string;
+    /** Business rule description in natural language */
+    business_rule?: string;
+    /** Algorithm description for complex formulas */
+    algorithm?: string;
+    /** Example calculations with inputs and expected results */
+    examples?: FormulaExample[];
+    /** Test cases for validation */
+    test_cases?: FormulaTestCase[];
+    /** Validation notes or constraints */
+    validation_notes?: string;
+    /** References to external documentation */
+    references?: string[];
+}
+/**
+ * Example demonstrating formula behavior
+ */
+export interface FormulaExample {
+    /** Description of this example */
+    description: string;
+    /** Input field values */
+    inputs: Record<string, FormulaFieldValue>;
+    /** Expected result */
+    result: FormulaValue;
+    /** Optional explanation of the calculation */
+    explanation?: string;
+}
+/**
+ * Test case for formula validation
+ */
+export interface FormulaTestCase {
+    /** Test case description */
+    description?: string;
+    /** Input values for the test */
+    input: Record<string, FormulaFieldValue>;
+    /** Expected output value */
+    expected: FormulaValue;
+    /** Whether this test should pass or fail */
+    should_pass?: boolean;
+}
+/**
+ * Runtime context for formula evaluation
+ *
+ * Provides access to record data, system variables, and user context
+ * during formula expression evaluation.
+ */
+export interface FormulaContext {
+    /** Current record data with all field values */
+    record: Record<string, FormulaFieldValue>;
+    /** System date/time variables */
+    system: FormulaSystemVariables;
+    /** Current user context */
+    current_user: FormulaUserContext;
+    /** Record context flags */
+    is_new: boolean;
+    /** Record ID (if exists) */
+    record_id?: string;
+}
+/**
+ * System variables available in formula expressions
+ */
+export interface FormulaSystemVariables {
+    /** Current date (YYYY-MM-DD) */
+    today: Date;
+    /** Current timestamp */
+    now: Date;
+    /** Current year */
+    year: number;
+    /** Current month (1-12) */
+    month: number;
+    /** Current day of month (1-31) */
+    day: number;
+    /** Current hour (0-23) */
+    hour: number;
+    /** Current minute (0-59) */
+    minute?: number;
+    /** Current second (0-59) */
+    second?: number;
+}
+/**
+ * Current user context available in formula expressions
+ */
+export interface FormulaUserContext {
+    /** User ID */
+    id: string;
+    /** User's display name */
+    name?: string;
+    /** User's email address */
+    email?: string;
+    /** User's role */
+    role?: string;
+    /** Additional user properties */
+    [key: string]: unknown;
+}
+/**
+ * Result of formula evaluation
+ */
+export interface FormulaEvaluationResult {
+    /** Computed value */
+    value: FormulaValue;
+    /** Data type of the result */
+    type: FormulaDataType;
+    /** Whether evaluation was successful */
+    success: boolean;
+    /** Error message if evaluation failed */
+    error?: string;
+    /** Stack trace for debugging (if error occurred) */
+    stack?: string;
+    /** Execution time in milliseconds */
+    execution_time?: number;
+}
+/**
+ * Error types that can occur during formula evaluation
+ */
+export declare enum FormulaErrorType {
+    /** Syntax error in the expression */
+    SYNTAX_ERROR = "SYNTAX_ERROR",
+    /** Referenced field does not exist */
+    FIELD_NOT_FOUND = "FIELD_NOT_FOUND",
+    /** Type mismatch in operation */
+    TYPE_ERROR = "TYPE_ERROR",
+    /** Division by zero */
+    DIVISION_BY_ZERO = "DIVISION_BY_ZERO",
+    /** Null or undefined value in operation */
+    NULL_REFERENCE = "NULL_REFERENCE",
+    /** Evaluation timeout */
+    TIMEOUT = "TIMEOUT",
+    /** Security violation (restricted operation) */
+    SECURITY_VIOLATION = "SECURITY_VIOLATION",
+    /** Generic runtime error */
+    RUNTIME_ERROR = "RUNTIME_ERROR"
+}
+/**
+ * Context information for formula errors
+ */
+export interface FormulaErrorContext {
+    /** The formula expression that caused the error */
+    expression?: string;
+    /** Field name if applicable */
+    field?: string;
+    /** Record data at time of error */
+    record?: Record<string, FormulaFieldValue>;
+    /** Additional context information */
+    [key: string]: unknown;
+}
+/**
+ * Custom error for formula evaluation failures
+ * Extends ObjectQLError to maintain consistency with ObjectQL error handling
+ */
+export declare class FormulaError extends ObjectQLError {
+    readonly errorType: FormulaErrorType;
+    readonly expression?: string;
+    readonly errorContext?: FormulaErrorContext;
+    constructor(type: FormulaErrorType, message: string, expression?: string, context?: FormulaErrorContext);
+}
+/**
+ * Options for formula evaluation
+ */
+export interface FormulaEvaluationOptions {
+    /** Maximum execution time in milliseconds (default: 1000) */
+    timeout?: number;
+    /** Enable strict mode (default: true) */
+    strict?: boolean;
+    /** Enable debug mode with detailed logging */
+    debug?: boolean;
+    /** Allow async operations (default: false) */
+    allow_async?: boolean;
+    /** Sandbox restrictions */
+    sandbox?: {
+        /** Allowed global variables */
+        allowed_globals?: string[];
+        /** Blocked operations/methods */
+        blocked_operations?: string[];
+    };
+}
+/**
+ * Metadata about a formula field for introspection
+ */
+export interface FormulaMetadata {
+    /** Formula field name */
+    field_name: string;
+    /** The formula expression */
+    expression: string;
+    /** Expected return type */
+    data_type: FormulaDataType;
+    /** Fields referenced in the expression */
+    dependencies: string[];
+    /** Lookup chains used (e.g., ["account.owner.name"]) */
+    lookup_chains: string[];
+    /** System variables used */
+    system_variables: string[];
+    /** Whether the formula is valid */
+    is_valid: boolean;
+    /** Validation errors if invalid */
+    validation_errors?: string[];
+    /** Estimated complexity (simple, medium, complex) */
+    complexity?: 'simple' | 'medium' | 'complex';
+}
+/**
+ * Statistics about formula execution
+ */
+export interface FormulaExecutionStats {
+    /** Formula field name */
+    field_name: string;
+    /** Total number of evaluations */
+    evaluation_count: number;
+    /** Number of successful evaluations */
+    success_count: number;
+    /** Number of failed evaluations */
+    error_count: number;
+    /** Average execution time in milliseconds */
+    avg_execution_time: number;
+    /** Maximum execution time in milliseconds */
+    max_execution_time: number;
+    /** Minimum execution time in milliseconds */
+    min_execution_time: number;
+    /** Most common error types */
+    common_errors?: Record<FormulaErrorType, number>;
+}
+/**
+ * Type for custom formula functions
+ * These functions can be registered in the formula engine for use in expressions
+ */
+export type FormulaCustomFunction = (...args: FormulaFieldValue[]) => FormulaValue;
+/**
+ * Configuration for formula engine
+ */
+export interface FormulaEngineConfig {
+    /** Enable formula caching */
+    enable_cache?: boolean;
+    /** Cache TTL in seconds */
+    cache_ttl?: number;
+    /** Maximum formula execution time in milliseconds */
+    max_execution_time?: number;
+    /** Enable performance monitoring */
+    enable_monitoring?: boolean;
+    /** Custom function library */
+    custom_functions?: Record<string, FormulaCustomFunction>;
+    /** Sandbox configuration */
+    sandbox?: {
+        /** Enable sandbox mode */
+        enabled?: boolean;
+        /** Allowed global objects */
+        allowed_globals?: string[];
+        /** Blocked operations */
+        blocked_operations?: string[];
+    };
+}

package/dist/formula.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Formula Engine Types
+ *
+ * Type definitions for the ObjectQL Formula Engine.
+ * Formulas are read-only calculated fields that derive values from other fields,
+ * related records, or system variables using JavaScript-style expressions.
+ *
+ * @see docs/spec/formula.md for complete specification
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormulaError = exports.FormulaErrorType = void 0;
+const api_1 = require("./api");
+/**
+ * Error types that can occur during formula evaluation
+ */
+var FormulaErrorType;
+(function (FormulaErrorType) {
+    /** Syntax error in the expression */
+    FormulaErrorType["SYNTAX_ERROR"] = "SYNTAX_ERROR";
+    /** Referenced field does not exist */
+    FormulaErrorType["FIELD_NOT_FOUND"] = "FIELD_NOT_FOUND";
+    /** Type mismatch in operation */
+    FormulaErrorType["TYPE_ERROR"] = "TYPE_ERROR";
+    /** Division by zero */
+    FormulaErrorType["DIVISION_BY_ZERO"] = "DIVISION_BY_ZERO";
+    /** Null or undefined value in operation */
+    FormulaErrorType["NULL_REFERENCE"] = "NULL_REFERENCE";
+    /** Evaluation timeout */
+    FormulaErrorType["TIMEOUT"] = "TIMEOUT";
+    /** Security violation (restricted operation) */
+    FormulaErrorType["SECURITY_VIOLATION"] = "SECURITY_VIOLATION";
+    /** Generic runtime error */
+    FormulaErrorType["RUNTIME_ERROR"] = "RUNTIME_ERROR";
+})(FormulaErrorType || (exports.FormulaErrorType = FormulaErrorType = {}));
+/**
+ * Custom error for formula evaluation failures
+ * Extends ObjectQLError to maintain consistency with ObjectQL error handling
+ */
+class FormulaError extends api_1.ObjectQLError {
+    constructor(type, message, expression, context) {
+        super({
+            code: type,
+            message,
+            details: {
+                formula_error_type: type,
+                expression,
+                ...context
+            }
+        });
+        this.name = 'FormulaError';
+        this.errorType = type;
+        this.expression = expression;
+        this.errorContext = context;
+    }
+}
+exports.FormulaError = FormulaError;
+//# sourceMappingURL=formula.js.map

package/dist/formula.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formula.js","sourceRoot":"","sources":["../src/formula.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AAEH,+BAAoD;AA0OpD;;GAEG;AACH,IAAY,gBAwBX;AAxBD,WAAY,gBAAgB;IACxB,qCAAqC;IACrC,iDAA6B,CAAA;IAE7B,sCAAsC;IACtC,uDAAmC,CAAA;IAEnC,iCAAiC;IACjC,6CAAyB,CAAA;IAEzB,uBAAuB;IACvB,yDAAqC,CAAA;IAErC,2CAA2C;IAC3C,qDAAiC,CAAA;IAEjC,yBAAyB;IACzB,uCAAmB,CAAA;IAEnB,gDAAgD;IAChD,6DAAyC,CAAA;IAEzC,4BAA4B;IAC5B,mDAA+B,CAAA;AACnC,CAAC,EAxBW,gBAAgB,gCAAhB,gBAAgB,QAwB3B;AAmBD;;;GAGG;AACH,MAAa,YAAa,SAAQ,mBAAa;IAK3C,YACI,IAAsB,EACtB,OAAe,EACf,UAAmB,EACnB,OAA6B;QAE7B,KAAK,CAAC;YACF,IAAI,EAAE,IAAc;YACpB,OAAO;YACP,OAAO,EAAE;gBACL,kBAAkB,EAAE,IAAI;gBACxB,UAAU;gBACV,GAAG,OAAO;aACb;SACJ,CAAC,CAAC;QACH,IAAI,CAAC,IAAI,GAAG,cAAc,CAAC;QAC3B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC;IAChC,CAAC;CACJ;AAzBD,oCAyBC"}

package/dist/index.d.ts

@@ -18,3 +18,8 @@ export * from './application';
 export * from './menu';
 export * from './migration';
 export * from './api';
+export * from './view';
+export * from './workflow';
+export * from './report';
+export * from './form';
+export * from './formula';

package/dist/index.js

@@ -34,4 +34,9 @@ __exportStar(require("./application"), exports);
 __exportStar(require("./menu"), exports);
 __exportStar(require("./migration"), exports);
 __exportStar(require("./api"), exports);
+__exportStar(require("./view"), exports);
+__exportStar(require("./workflow"), exports);
+__exportStar(require("./report"), exports);
+__exportStar(require("./form"), exports);
+__exportStar(require("./formula"), exports);
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAwB;AACxB,2CAAyB;AACzB,2CAAyB;AACzB,0CAAwB;AACxB,6CAA2B;AAC3B,yCAAuB;AACvB,2CAAyB;AACzB,+CAA6B;AAC7B,wCAAsB;AACtB,2CAAyB;AACzB,2CAAyB;AACzB,4CAA0B;AAC1B,+CAA6B;AAC7B,+CAA6B;AAC7B,yCAAuB;AACvB,2CAAyB;AACzB,gDAA8B;AAC9B,yCAAuB;AACvB,8CAA4B;AAC5B,wCAAsB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAwB;AACxB,2CAAyB;AACzB,2CAAyB;AACzB,0CAAwB;AACxB,6CAA2B;AAC3B,yCAAuB;AACvB,2CAAyB;AACzB,+CAA6B;AAC7B,wCAAsB;AACtB,2CAAyB;AACzB,2CAAyB;AACzB,4CAA0B;AAC1B,+CAA6B;AAC7B,+CAA6B;AAC7B,yCAAuB;AACvB,2CAAyB;AACzB,gDAA8B;AAC9B,yCAAuB;AACvB,8CAA4B;AAC5B,wCAAsB;AACtB,yCAAuB;AACvB,6CAA2B;AAC3B,2CAAyB;AACzB,yCAAuB;AACvB,4CAA0B"}

package/dist/report.d.ts

@@ -0,0 +1,276 @@
+/**
+ * Report Metadata Definition
+ *
+ * Defines the structure for reports, data summaries, and analytics in ObjectQL.
+ * Reports aggregate and visualize data from objects with grouping, filtering, and calculations.
+ *
+ * Based on patterns from Salesforce Reports, Tableau, and similar BI platforms.
+ */
+import { ViewFilter, ViewFilterGroup, ViewColumn } from './view';
+/**
+ * Types of reports supported by ObjectQL
+ */
+export type ReportType = 'tabular' | 'summary' | 'matrix' | 'chart' | 'dashboard' | 'custom';
+/**
+ * Chart types for visualization
+ */
+export type ChartType = 'bar' | 'column' | 'line' | 'area' | 'pie' | 'donut' | 'scatter' | 'bubble' | 'funnel' | 'gauge' | 'radar' | 'heatmap' | 'treemap' | 'waterfall' | 'custom';
+/**
+ * Aggregation functions for report calculations
+ */
+export type AggregationFunction = 'count' | 'sum' | 'avg' | 'min' | 'max' | 'median' | 'mode' | 'stddev' | 'variance' | 'distinct_count' | 'first' | 'last' | 'custom';
+/**
+ * Grouping configuration for reports
+ */
+export interface ReportGrouping {
+    /** Field to group by */
+    field: string;
+    /** Display label */
+    label?: string;
+    /** Sort order for groups */
+    sort?: 'asc' | 'desc';
+    /** Group by date interval (for date fields) */
+    date_interval?: 'day' | 'week' | 'month' | 'quarter' | 'year';
+    /** Group by numeric range (for numeric fields) */
+    numeric_range?: {
+        /** Range size */
+        size: number;
+        /** Starting value */
+        start?: number;
+    };
+    /** Show subtotals for this grouping */
+    show_subtotals?: boolean;
+    /** Limit number of groups */
+    limit?: number;
+}
+/**
+ * Aggregation/calculation configuration
+ */
+export interface ReportAggregation {
+    /** Field to aggregate */
+    field: string;
+    /** Aggregation function */
+    function: AggregationFunction;
+    /** Display label */
+    label?: string;
+    /** Display format */
+    format?: string;
+    /** Custom aggregation expression */
+    expression?: string;
+    /** Show in totals row */
+    show_in_total?: boolean;
+}
+/**
+ * Formula field for calculated columns
+ */
+export interface ReportFormula {
+    /** Formula name */
+    name: string;
+    /** Display label */
+    label?: string;
+    /** Formula expression */
+    expression: string;
+    /** Data type of result */
+    type?: 'number' | 'text' | 'date' | 'boolean';
+    /** Display format */
+    format?: string;
+    /** Description of what this formula calculates */
+    description?: string;
+}
+/**
+ * Chart configuration for report visualization
+ */
+export interface ReportChartConfig {
+    /** Chart type */
+    type: ChartType;
+    /** Chart title */
+    title?: string;
+    /** Field for X-axis */
+    x_axis?: string;
+    /** Field(s) for Y-axis */
+    y_axis?: string | string[];
+    /** Field for chart series/legend */
+    series_field?: string;
+    /** Chart colors */
+    colors?: string[];
+    /** Show legend */
+    show_legend?: boolean;
+    /** Legend position */
+    legend_position?: 'top' | 'bottom' | 'left' | 'right';
+    /** Show data labels */
+    show_data_labels?: boolean;
+    /** Chart height in pixels */
+    height?: number;
+    /** Chart width in pixels */
+    width?: number;
+    /** Enable drill-down */
+    enable_drill_down?: boolean;
+    /** Custom chart configuration */
+    custom_config?: Record<string, any>;
+}
+/**
+ * Matrix report dimension configuration
+ */
+export interface MatrixDimension {
+    /** Field for this dimension */
+    field: string;
+    /** Display label */
+    label?: string;
+    /** Sort order */
+    sort?: 'asc' | 'desc';
+    /** Show totals */
+    show_totals?: boolean;
+}
+/**
+ * Export configuration for reports
+ */
+export interface ReportExportConfig {
+    /** Enabled export formats */
+    formats?: ('pdf' | 'xlsx' | 'csv' | 'json' | 'html')[];
+    /** Include charts in export */
+    include_charts?: boolean;
+    /** Export filename template */
+    filename_template?: string;
+    /** Page orientation for PDF */
+    page_orientation?: 'portrait' | 'landscape';
+    /** Paper size for PDF */
+    paper_size?: 'A4' | 'Letter' | 'Legal';
+}
+/**
+ * Scheduling configuration for automated reports
+ */
+export interface ReportScheduleConfig {
+    /** Enable scheduled execution */
+    enabled: boolean;
+    /** Cron expression for schedule */
+    cron?: string;
+    /** Timezone for schedule */
+    timezone?: string;
+    /** Email recipients for scheduled reports */
+    recipients?: string[];
+    /** Email subject template */
+    email_subject?: string;
+    /** Email body template */
+    email_body?: string;
+    /** Export format for scheduled report */
+    format?: 'pdf' | 'xlsx' | 'csv';
+}
+/**
+ * Complete report configuration
+ */
+export interface ReportConfig {
+    /** Unique report identifier */
+    name: string;
+    /** Display label */
+    label: string;
+    /** Report type */
+    type: ReportType;
+    /** Primary object for the report */
+    object: string;
+    /** Report description */
+    description?: string;
+    /** Icon for the report */
+    icon?: string;
+    /** Columns to display */
+    columns?: ViewColumn[];
+    /** Filters to apply */
+    filters?: (ViewFilter | ViewFilterGroup)[];
+    /** Grouping configuration */
+    groupings?: ReportGrouping[];
+    /** Aggregations/calculations */
+    aggregations?: ReportAggregation[];
+    /** Formula fields */
+    formulas?: ReportFormula[];
+    /** Chart configuration */
+    chart?: ReportChartConfig;
+    /** Matrix report row dimension */
+    row_dimension?: MatrixDimension;
+    /** Matrix report column dimension */
+    column_dimension?: MatrixDimension;
+    /** Limit number of rows */
+    limit?: number;
+    /** Enable drill-down to records */
+    enable_drill_down?: boolean;
+    /** Show record count */
+    show_record_count?: boolean;
+    /** Show grand totals */
+    show_grand_total?: boolean;
+    /** Export configuration */
+    export?: ReportExportConfig;
+    /** Scheduling configuration */
+    schedule?: ReportScheduleConfig;
+    /** Cache configuration */
+    cache?: {
+        /** Enable caching */
+        enabled?: boolean;
+        /** Cache duration in seconds */
+        duration?: number;
+    };
+    /** Access control */
+    permissions?: {
+        /** Roles that can view this report */
+        view?: string[];
+        /** Roles that can edit report configuration */
+        edit?: string[];
+        /** Roles that can export */
+        export?: string[];
+    };
+    /** Whether this report is shared with all users */
+    is_public?: boolean;
+    /** Owner of the report (for personal reports) */
+    owner?: string;
+    /** Folder/category for organization */
+    folder?: string;
+    /** Custom report configuration */
+    config?: Record<string, any>;
+    /** AI context for report generation */
+    ai_context?: {
+        /** Business question this report answers */
+        intent?: string;
+        /** Target audience */
+        audience?: string;
+        /** Key insights to highlight */
+        insights?: string[];
+        /** Recommended visualizations */
+        visualizations?: string[];
+    };
+}
+/**
+ * Report execution result
+ */
+export interface ReportResult {
+    /** Report name */
+    report_name: string;
+    /** Execution timestamp */
+    executed_at: string;
+    /** Data rows */
+    rows: any[];
+    /** Total record count */
+    total_count: number;
+    /** Aggregation results */
+    aggregations?: Record<string, any>;
+    /** Grand totals */
+    grand_total?: Record<string, any>;
+    /** Chart data */
+    chart_data?: any;
+    /** Execution time in milliseconds */
+    execution_time?: number;
+    /** Whether result was from cache */
+    from_cache?: boolean;
+}
+/**
+ * Lightweight report reference
+ * Used in navigation, dropdowns, and report selectors
+ */
+export interface ReportReference {
+    /** Report name/identifier */
+    name: string;
+    /** Display label */
+    label?: string;
+    /** Icon */
+    icon?: string;
+    /** Report type */
+    type?: ReportType;
+    /** Folder/category */
+    folder?: string;
+}

package/dist/report.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * Report Metadata Definition
+ *
+ * Defines the structure for reports, data summaries, and analytics in ObjectQL.
+ * Reports aggregate and visualize data from objects with grouping, filtering, and calculations.
+ *
+ * Based on patterns from Salesforce Reports, Tableau, and similar BI platforms.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=report.js.map

package/dist/report.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.js","sourceRoot":"","sources":["../src/report.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG"}