@elaraai/east-py-datascience 0.0.2-beta.8 → 0.0.2-beta.80

package/dist/src/lightgbm/lightgbm.d.ts

@@ -0,0 +1,575 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * LightGBM platform functions for East.
+ *
+ * Provides fast gradient boosting for regression and classification.
+ * Uses cloudpickle for model serialization.
+ *
+ * @packageDocumentation
+ */
+import { StructType, VariantType, OptionType, IntegerType, FloatType, BlobType } from "@elaraai/east";
+import { VectorType, MatrixType } from "../types.js";
+export { VectorType, MatrixType } from "../types.js";
+/**
+ * Configuration for LightGBM models.
+ */
+export declare const LightGBMConfigType: StructType<{
+    /** Number of boosting rounds (default 100) */
+    readonly n_estimators: OptionType<IntegerType>;
+    /** Maximum tree depth, -1 for unlimited (default -1) */
+    readonly max_depth: OptionType<IntegerType>;
+    /** Learning rate / step size shrinkage (default 0.1) */
+    readonly learning_rate: OptionType<FloatType>;
+    /** Maximum number of leaves in one tree (default 31) */
+    readonly num_leaves: OptionType<IntegerType>;
+    /** Minimum number of samples required in a leaf (default 20) */
+    readonly min_child_samples: OptionType<IntegerType>;
+    /** Subsample ratio of training instances (default 1.0) */
+    readonly subsample: OptionType<FloatType>;
+    /** Subsample ratio of columns when constructing trees (default 1.0) */
+    readonly colsample_bytree: OptionType<FloatType>;
+    /** L1 regularization term (default 0) */
+    readonly reg_alpha: OptionType<FloatType>;
+    /** L2 regularization term (default 0) */
+    readonly reg_lambda: OptionType<FloatType>;
+    /** Random seed for reproducibility */
+    readonly random_state: OptionType<IntegerType>;
+    /** Number of parallel threads (default -1 for all cores) */
+    readonly n_jobs: OptionType<IntegerType>;
+}>;
+/**
+ * Model blob type for serialized LightGBM models.
+ *
+ * Each model type has its own variant case containing cloudpickle bytes and metadata.
+ */
+export declare const LightGBMModelBlobType: VariantType<{
+    /** LightGBM regressor model */
+    readonly lightgbm_regressor: StructType<{
+        /** Cloudpickle serialized model */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+    }>;
+    /** LightGBM classifier model */
+    readonly lightgbm_classifier: StructType<{
+        /** Cloudpickle serialized model */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of classes */
+        readonly n_classes: IntegerType;
+    }>;
+}>;
+/**
+ * Train a LightGBM regression model.
+ *
+ * @param X - Feature matrix
+ * @param y - Target vector
+ * @param config - LightGBM configuration
+ * @returns Model blob containing trained regressor
+ */
+export declare const lightgbm_train_regressor: import("@elaraai/east").PlatformDefinition<[MatrixType<FloatType>, VectorType<FloatType>, StructType<{
+    /** Number of boosting rounds (default 100) */
+    readonly n_estimators: OptionType<IntegerType>;
+    /** Maximum tree depth, -1 for unlimited (default -1) */
+    readonly max_depth: OptionType<IntegerType>;
+    /** Learning rate / step size shrinkage (default 0.1) */
+    readonly learning_rate: OptionType<FloatType>;
+    /** Maximum number of leaves in one tree (default 31) */
+    readonly num_leaves: OptionType<IntegerType>;
+    /** Minimum number of samples required in a leaf (default 20) */
+    readonly min_child_samples: OptionType<IntegerType>;
+    /** Subsample ratio of training instances (default 1.0) */
+    readonly subsample: OptionType<FloatType>;
+    /** Subsample ratio of columns when constructing trees (default 1.0) */
+    readonly colsample_bytree: OptionType<FloatType>;
+    /** L1 regularization term (default 0) */
+    readonly reg_alpha: OptionType<FloatType>;
+    /** L2 regularization term (default 0) */
+    readonly reg_lambda: OptionType<FloatType>;
+    /** Random seed for reproducibility */
+    readonly random_state: OptionType<IntegerType>;
+    /** Number of parallel threads (default -1 for all cores) */
+    readonly n_jobs: OptionType<IntegerType>;
+}>], VariantType<{
+    /** LightGBM regressor model */
+    readonly lightgbm_regressor: StructType<{
+        /** Cloudpickle serialized model */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+    }>;
+    /** LightGBM classifier model */
+    readonly lightgbm_classifier: StructType<{
+        /** Cloudpickle serialized model */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of classes */
+        readonly n_classes: IntegerType;
+    }>;
+}>>;
+/**
+ * Train a LightGBM classification model.
+ *
+ * @param X - Feature matrix
+ * @param y - Label vector (integer class labels)
+ * @param config - LightGBM configuration
+ * @returns Model blob containing trained classifier
+ */
+export declare const lightgbm_train_classifier: import("@elaraai/east").PlatformDefinition<[MatrixType<FloatType>, VectorType<IntegerType>, StructType<{
+    /** Number of boosting rounds (default 100) */
+    readonly n_estimators: OptionType<IntegerType>;
+    /** Maximum tree depth, -1 for unlimited (default -1) */
+    readonly max_depth: OptionType<IntegerType>;
+    /** Learning rate / step size shrinkage (default 0.1) */
+    readonly learning_rate: OptionType<FloatType>;
+    /** Maximum number of leaves in one tree (default 31) */
+    readonly num_leaves: OptionType<IntegerType>;
+    /** Minimum number of samples required in a leaf (default 20) */
+    readonly min_child_samples: OptionType<IntegerType>;
+    /** Subsample ratio of training instances (default 1.0) */
+    readonly subsample: OptionType<FloatType>;
+    /** Subsample ratio of columns when constructing trees (default 1.0) */
+    readonly colsample_bytree: OptionType<FloatType>;
+    /** L1 regularization term (default 0) */
+    readonly reg_alpha: OptionType<FloatType>;
+    /** L2 regularization term (default 0) */
+    readonly reg_lambda: OptionType<FloatType>;
+    /** Random seed for reproducibility */
+    readonly random_state: OptionType<IntegerType>;
+    /** Number of parallel threads (default -1 for all cores) */
+    readonly n_jobs: OptionType<IntegerType>;
+}>], VariantType<{
+    /** LightGBM regressor model */
+    readonly lightgbm_regressor: StructType<{
+        /** Cloudpickle serialized model */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+    }>;
+    /** LightGBM classifier model */
+    readonly lightgbm_classifier: StructType<{
+        /** Cloudpickle serialized model */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of classes */
+        readonly n_classes: IntegerType;
+    }>;
+}>>;
+/**
+ * Make predictions with a trained LightGBM regressor.
+ *
+ * @param model - Trained regressor model blob
+ * @param X - Feature matrix
+ * @returns Predicted values
+ */
+export declare const lightgbm_predict: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** LightGBM regressor model */
+    readonly lightgbm_regressor: StructType<{
+        /** Cloudpickle serialized model */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+    }>;
+    /** LightGBM classifier model */
+    readonly lightgbm_classifier: StructType<{
+        /** Cloudpickle serialized model */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of classes */
+        readonly n_classes: IntegerType;
+    }>;
+}>, MatrixType<FloatType>], VectorType<FloatType>>;
+/**
+ * Predict class labels with a trained LightGBM classifier.
+ *
+ * @param model - Trained classifier model blob
+ * @param X - Feature matrix
+ * @returns Predicted class labels
+ */
+export declare const lightgbm_predict_class: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** LightGBM regressor model */
+    readonly lightgbm_regressor: StructType<{
+        /** Cloudpickle serialized model */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+    }>;
+    /** LightGBM classifier model */
+    readonly lightgbm_classifier: StructType<{
+        /** Cloudpickle serialized model */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of classes */
+        readonly n_classes: IntegerType;
+    }>;
+}>, MatrixType<FloatType>], VectorType<IntegerType>>;
+/**
+ * Get class probabilities from a trained LightGBM classifier.
+ *
+ * @param model - Trained classifier model blob
+ * @param X - Feature matrix
+ * @returns Probability matrix (n_samples x n_classes)
+ */
+export declare const lightgbm_predict_proba: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** LightGBM regressor model */
+    readonly lightgbm_regressor: StructType<{
+        /** Cloudpickle serialized model */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+    }>;
+    /** LightGBM classifier model */
+    readonly lightgbm_classifier: StructType<{
+        /** Cloudpickle serialized model */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of classes */
+        readonly n_classes: IntegerType;
+    }>;
+}>, MatrixType<FloatType>], MatrixType<FloatType>>;
+/**
+ * Type definitions for LightGBM functions.
+ */
+export declare const LightGBMTypes: {
+    /** LightGBM configuration type */
+    readonly LightGBMConfigType: StructType<{
+        /** Number of boosting rounds (default 100) */
+        readonly n_estimators: OptionType<IntegerType>;
+        /** Maximum tree depth, -1 for unlimited (default -1) */
+        readonly max_depth: OptionType<IntegerType>;
+        /** Learning rate / step size shrinkage (default 0.1) */
+        readonly learning_rate: OptionType<FloatType>;
+        /** Maximum number of leaves in one tree (default 31) */
+        readonly num_leaves: OptionType<IntegerType>;
+        /** Minimum number of samples required in a leaf (default 20) */
+        readonly min_child_samples: OptionType<IntegerType>;
+        /** Subsample ratio of training instances (default 1.0) */
+        readonly subsample: OptionType<FloatType>;
+        /** Subsample ratio of columns when constructing trees (default 1.0) */
+        readonly colsample_bytree: OptionType<FloatType>;
+        /** L1 regularization term (default 0) */
+        readonly reg_alpha: OptionType<FloatType>;
+        /** L2 regularization term (default 0) */
+        readonly reg_lambda: OptionType<FloatType>;
+        /** Random seed for reproducibility */
+        readonly random_state: OptionType<IntegerType>;
+        /** Number of parallel threads (default -1 for all cores) */
+        readonly n_jobs: OptionType<IntegerType>;
+    }>;
+    /** Model blob type for LightGBM models */
+    readonly ModelBlobType: VariantType<{
+        /** LightGBM regressor model */
+        readonly lightgbm_regressor: StructType<{
+            /** Cloudpickle serialized model */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+        }>;
+        /** LightGBM classifier model */
+        readonly lightgbm_classifier: StructType<{
+            /** Cloudpickle serialized model */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of classes */
+            readonly n_classes: IntegerType;
+        }>;
+    }>;
+};
+/**
+ * LightGBM gradient boosting.
+ *
+ * Provides fast regression and classification with gradient boosted decision trees.
+ */
+export declare const LightGBM: {
+    /**
+     * Train a LightGBM regression model.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType, VectorType, variant } from "@elaraai/east";
+     * import { LightGBM, LightGBMConfigType } from "@elaraai/east-py-datascience";
+     *
+     * const train = East.function([], LightGBM.Types.ModelBlobType, ($) => {
+     *     const X = $.let([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0]]);
+     *     const y = $.let(new Float64Array([1.0, 2.0, 3.0, 4.0]));
+     *     const config = $.let({
+     *         n_estimators: variant("some", 100n), max_depth: variant("some", 3n),
+     *         learning_rate: variant("some", 0.1), num_leaves: variant("none", null),
+     *         min_child_samples: variant("none", null), subsample: variant("none", null),
+     *         colsample_bytree: variant("none", null), reg_alpha: variant("none", null),
+     *         reg_lambda: variant("none", null), random_state: variant("some", 42n),
+     *         n_jobs: variant("none", null),
+     *     }, LightGBMConfigType);
+     *     return $.return(LightGBM.trainRegressor(X, y, config));
+     * });
+     * ```
+     */
+    readonly trainRegressor: import("@elaraai/east").PlatformDefinition<[MatrixType<FloatType>, VectorType<FloatType>, StructType<{
+        /** Number of boosting rounds (default 100) */
+        readonly n_estimators: OptionType<IntegerType>;
+        /** Maximum tree depth, -1 for unlimited (default -1) */
+        readonly max_depth: OptionType<IntegerType>;
+        /** Learning rate / step size shrinkage (default 0.1) */
+        readonly learning_rate: OptionType<FloatType>;
+        /** Maximum number of leaves in one tree (default 31) */
+        readonly num_leaves: OptionType<IntegerType>;
+        /** Minimum number of samples required in a leaf (default 20) */
+        readonly min_child_samples: OptionType<IntegerType>;
+        /** Subsample ratio of training instances (default 1.0) */
+        readonly subsample: OptionType<FloatType>;
+        /** Subsample ratio of columns when constructing trees (default 1.0) */
+        readonly colsample_bytree: OptionType<FloatType>;
+        /** L1 regularization term (default 0) */
+        readonly reg_alpha: OptionType<FloatType>;
+        /** L2 regularization term (default 0) */
+        readonly reg_lambda: OptionType<FloatType>;
+        /** Random seed for reproducibility */
+        readonly random_state: OptionType<IntegerType>;
+        /** Number of parallel threads (default -1 for all cores) */
+        readonly n_jobs: OptionType<IntegerType>;
+    }>], VariantType<{
+        /** LightGBM regressor model */
+        readonly lightgbm_regressor: StructType<{
+            /** Cloudpickle serialized model */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+        }>;
+        /** LightGBM classifier model */
+        readonly lightgbm_classifier: StructType<{
+            /** Cloudpickle serialized model */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of classes */
+            readonly n_classes: IntegerType;
+        }>;
+    }>>;
+    /**
+     * Train a LightGBM classification model.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, IntegerType, MatrixType, VectorType, variant } from "@elaraai/east";
+     * import { LightGBM, LightGBMConfigType } from "@elaraai/east-py-datascience";
+     *
+     * const train = East.function([], LightGBM.Types.ModelBlobType, ($) => {
+     *     const X = $.let([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0]]);
+     *     const y = $.let(new BigInt64Array([0n, 1n, 0n, 1n]));
+     *     const config = $.let({
+     *         n_estimators: variant("some", 50n), max_depth: variant("some", 3n),
+     *         learning_rate: variant("some", 0.1), num_leaves: variant("none", null),
+     *         min_child_samples: variant("none", null), subsample: variant("none", null),
+     *         colsample_bytree: variant("none", null), reg_alpha: variant("none", null),
+     *         reg_lambda: variant("none", null), random_state: variant("some", 42n),
+     *         n_jobs: variant("none", null),
+     *     }, LightGBMConfigType);
+     *     return $.return(LightGBM.trainClassifier(X, y, config));
+     * });
+     * ```
+     */
+    readonly trainClassifier: import("@elaraai/east").PlatformDefinition<[MatrixType<FloatType>, VectorType<IntegerType>, StructType<{
+        /** Number of boosting rounds (default 100) */
+        readonly n_estimators: OptionType<IntegerType>;
+        /** Maximum tree depth, -1 for unlimited (default -1) */
+        readonly max_depth: OptionType<IntegerType>;
+        /** Learning rate / step size shrinkage (default 0.1) */
+        readonly learning_rate: OptionType<FloatType>;
+        /** Maximum number of leaves in one tree (default 31) */
+        readonly num_leaves: OptionType<IntegerType>;
+        /** Minimum number of samples required in a leaf (default 20) */
+        readonly min_child_samples: OptionType<IntegerType>;
+        /** Subsample ratio of training instances (default 1.0) */
+        readonly subsample: OptionType<FloatType>;
+        /** Subsample ratio of columns when constructing trees (default 1.0) */
+        readonly colsample_bytree: OptionType<FloatType>;
+        /** L1 regularization term (default 0) */
+        readonly reg_alpha: OptionType<FloatType>;
+        /** L2 regularization term (default 0) */
+        readonly reg_lambda: OptionType<FloatType>;
+        /** Random seed for reproducibility */
+        readonly random_state: OptionType<IntegerType>;
+        /** Number of parallel threads (default -1 for all cores) */
+        readonly n_jobs: OptionType<IntegerType>;
+    }>], VariantType<{
+        /** LightGBM regressor model */
+        readonly lightgbm_regressor: StructType<{
+            /** Cloudpickle serialized model */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+        }>;
+        /** LightGBM classifier model */
+        readonly lightgbm_classifier: StructType<{
+            /** Cloudpickle serialized model */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of classes */
+            readonly n_classes: IntegerType;
+        }>;
+    }>>;
+    /**
+     * Make predictions with a trained LightGBM regressor.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType, VectorType } from "@elaraai/east";
+     * import { LightGBM } from "@elaraai/east-py-datascience";
+     *
+     * const predictFn = East.function(
+     *     [LightGBM.Types.ModelBlobType, MatrixType(FloatType)],
+     *     VectorType(FloatType),
+     *     ($, model, X) => {
+     *         return $.return(LightGBM.predict(model, X));
+     *     }
+     * );
+     * ```
+     */
+    readonly predict: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** LightGBM regressor model */
+        readonly lightgbm_regressor: StructType<{
+            /** Cloudpickle serialized model */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+        }>;
+        /** LightGBM classifier model */
+        readonly lightgbm_classifier: StructType<{
+            /** Cloudpickle serialized model */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of classes */
+            readonly n_classes: IntegerType;
+        }>;
+    }>, MatrixType<FloatType>], VectorType<FloatType>>;
+    /**
+     * Predict class labels with a trained LightGBM classifier.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, IntegerType, MatrixType, VectorType } from "@elaraai/east";
+     * import { LightGBM } from "@elaraai/east-py-datascience";
+     *
+     * const predictFn = East.function(
+     *     [LightGBM.Types.ModelBlobType, MatrixType(FloatType)],
+     *     VectorType(IntegerType),
+     *     ($, model, X) => {
+     *         return $.return(LightGBM.predictClass(model, X));
+     *     }
+     * );
+     * ```
+     */
+    readonly predictClass: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** LightGBM regressor model */
+        readonly lightgbm_regressor: StructType<{
+            /** Cloudpickle serialized model */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+        }>;
+        /** LightGBM classifier model */
+        readonly lightgbm_classifier: StructType<{
+            /** Cloudpickle serialized model */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of classes */
+            readonly n_classes: IntegerType;
+        }>;
+    }>, MatrixType<FloatType>], VectorType<IntegerType>>;
+    /**
+     * Get class probabilities from a trained LightGBM classifier.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType } from "@elaraai/east";
+     * import { LightGBM } from "@elaraai/east-py-datascience";
+     *
+     * const predictFn = East.function(
+     *     [LightGBM.Types.ModelBlobType, MatrixType(FloatType)],
+     *     MatrixType(FloatType),
+     *     ($, model, X) => {
+     *         return $.return(LightGBM.predictProba(model, X));
+     *     }
+     * );
+     * ```
+     */
+    readonly predictProba: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** LightGBM regressor model */
+        readonly lightgbm_regressor: StructType<{
+            /** Cloudpickle serialized model */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+        }>;
+        /** LightGBM classifier model */
+        readonly lightgbm_classifier: StructType<{
+            /** Cloudpickle serialized model */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of classes */
+            readonly n_classes: IntegerType;
+        }>;
+    }>, MatrixType<FloatType>], MatrixType<FloatType>>;
+    /** Type definitions */
+    readonly Types: {
+        /** LightGBM configuration type */
+        readonly LightGBMConfigType: StructType<{
+            /** Number of boosting rounds (default 100) */
+            readonly n_estimators: OptionType<IntegerType>;
+            /** Maximum tree depth, -1 for unlimited (default -1) */
+            readonly max_depth: OptionType<IntegerType>;
+            /** Learning rate / step size shrinkage (default 0.1) */
+            readonly learning_rate: OptionType<FloatType>;
+            /** Maximum number of leaves in one tree (default 31) */
+            readonly num_leaves: OptionType<IntegerType>;
+            /** Minimum number of samples required in a leaf (default 20) */
+            readonly min_child_samples: OptionType<IntegerType>;
+            /** Subsample ratio of training instances (default 1.0) */
+            readonly subsample: OptionType<FloatType>;
+            /** Subsample ratio of columns when constructing trees (default 1.0) */
+            readonly colsample_bytree: OptionType<FloatType>;
+            /** L1 regularization term (default 0) */
+            readonly reg_alpha: OptionType<FloatType>;
+            /** L2 regularization term (default 0) */
+            readonly reg_lambda: OptionType<FloatType>;
+            /** Random seed for reproducibility */
+            readonly random_state: OptionType<IntegerType>;
+            /** Number of parallel threads (default -1 for all cores) */
+            readonly n_jobs: OptionType<IntegerType>;
+        }>;
+        /** Model blob type for LightGBM models */
+        readonly ModelBlobType: VariantType<{
+            /** LightGBM regressor model */
+            readonly lightgbm_regressor: StructType<{
+                /** Cloudpickle serialized model */
+                readonly data: BlobType;
+                /** Number of input features */
+                readonly n_features: IntegerType;
+            }>;
+            /** LightGBM classifier model */
+            readonly lightgbm_classifier: StructType<{
+                /** Cloudpickle serialized model */
+                readonly data: BlobType;
+                /** Number of input features */
+                readonly n_features: IntegerType;
+                /** Number of classes */
+                readonly n_classes: IntegerType;
+            }>;
+        }>;
+    };
+};
+//# sourceMappingURL=lightgbm.d.ts.map

package/dist/src/lightgbm/lightgbm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lightgbm.d.ts","sourceRoot":"","sources":["../../../src/lightgbm/lightgbm.ts"],"names":[],"mappings":"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"}