@fiado/type-kit 3.540.0 → 3.541.0

package/bin/rules/dtos/population/SegmentAggregateCondition.js

@@ -0,0 +1,71 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentAggregateCondition = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const SegmentLimits_1 = require("../../constants/SegmentLimits");
+const SegmentAggregateFnEnum_1 = require("../../enums/SegmentAggregateFnEnum");
+const SegmentConditionKindEnum_1 = require("../../enums/SegmentConditionKindEnum");
+const SegmentOperatorEnum_1 = require("../../enums/SegmentOperatorEnum");
+const SegmentColumnCondition_1 = require("./SegmentColumnCondition");
+const SegmentWindow_1 = require("./SegmentWindow");
+/** (b) Agregado con ventana relativa sobre una tabla relacionada (existe / cuenta / suma). `filters` elige QUE cuenta (estados, moneda...). */
+class SegmentAggregateCondition {
+}
+exports.SegmentAggregateCondition = SegmentAggregateCondition;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.Equals)(SegmentConditionKindEnum_1.SegmentConditionKindEnum.AGGREGATE),
+    __metadata("design:type", String)
+], SegmentAggregateCondition.prototype, "kind", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.Matches)(SegmentLimits_1.SEGMENT_IDENTIFIER_PATTERN),
+    __metadata("design:type", String)
+], SegmentAggregateCondition.prototype, "table", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsEnum)(SegmentAggregateFnEnum_1.SegmentAggregateFnEnum),
+    __metadata("design:type", String)
+], SegmentAggregateCondition.prototype, "fn", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.Matches)(SegmentLimits_1.SEGMENT_IDENTIFIER_PATTERN),
+    __metadata("design:type", String)
+], SegmentAggregateCondition.prototype, "column", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsEnum)(SegmentOperatorEnum_1.SegmentOperatorEnum),
+    __metadata("design:type", String)
+], SegmentAggregateCondition.prototype, "op", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsNumber)(),
+    __metadata("design:type", Number)
+], SegmentAggregateCondition.prototype, "value", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.ValidateNested)(),
+    (0, class_transformer_1.Type)(() => SegmentWindow_1.SegmentWindow),
+    __metadata("design:type", SegmentWindow_1.SegmentWindow)
+], SegmentAggregateCondition.prototype, "window", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsArray)(),
+    (0, class_validator_1.ArrayMaxSize)(10),
+    (0, class_validator_1.ValidateNested)({ each: true }),
+    (0, class_transformer_1.Type)(() => SegmentColumnCondition_1.SegmentColumnCondition),
+    __metadata("design:type", Array)
+], SegmentAggregateCondition.prototype, "filters", void 0);

package/bin/rules/dtos/population/SegmentColumnCondition.d.ts

@@ -0,0 +1,11 @@
+import { JsonValue } from '../../../common';
+import { SegmentConditionKindEnum } from '../../enums/SegmentConditionKindEnum';
+import { SegmentOperatorEnum } from '../../enums/SegmentOperatorEnum';
+/** (a) Columna de una tabla unida por `directoryid`. El tipo de `value` (escalar, lista o `{days}`) lo valida el compilador contra el tipo de Glue. */
+export declare class SegmentColumnCondition {
+    kind: SegmentConditionKindEnum.COLUMN;
+    table: string;
+    column: string;
+    op: SegmentOperatorEnum;
+    value?: JsonValue;
+}

package/bin/rules/dtos/population/SegmentColumnCondition.js

@@ -0,0 +1,46 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentColumnCondition = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const SegmentLimits_1 = require("../../constants/SegmentLimits");
+const SegmentConditionKindEnum_1 = require("../../enums/SegmentConditionKindEnum");
+const SegmentOperatorEnum_1 = require("../../enums/SegmentOperatorEnum");
+/** (a) Columna de una tabla unida por `directoryid`. El tipo de `value` (escalar, lista o `{days}`) lo valida el compilador contra el tipo de Glue. */
+class SegmentColumnCondition {
+}
+exports.SegmentColumnCondition = SegmentColumnCondition;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.Equals)(SegmentConditionKindEnum_1.SegmentConditionKindEnum.COLUMN),
+    __metadata("design:type", String)
+], SegmentColumnCondition.prototype, "kind", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.Matches)(SegmentLimits_1.SEGMENT_IDENTIFIER_PATTERN),
+    __metadata("design:type", String)
+], SegmentColumnCondition.prototype, "table", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.Matches)(SegmentLimits_1.SEGMENT_IDENTIFIER_PATTERN),
+    __metadata("design:type", String)
+], SegmentColumnCondition.prototype, "column", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsEnum)(SegmentOperatorEnum_1.SegmentOperatorEnum),
+    __metadata("design:type", String)
+], SegmentColumnCondition.prototype, "op", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", Object)
+], SegmentColumnCondition.prototype, "value", void 0);

package/bin/rules/dtos/population/SegmentGroup.d.ts

@@ -0,0 +1,9 @@
+import { SegmentMatchEnum } from '../../enums/SegmentMatchEnum';
+import { SegmentAggregateCondition } from './SegmentAggregateCondition';
+import { SegmentColumnCondition } from './SegmentColumnCondition';
+export type SegmentCondition = SegmentColumnCondition | SegmentAggregateCondition;
+export declare class SegmentGroup {
+    match: SegmentMatchEnum;
+    /** `kind` decide la clase; un `kind` desconocido NO se instancia y la validacion lo rechaza (el objeto queda sin `@Equals` valido). */
+    conditions: SegmentCondition[];
+}

package/bin/rules/dtos/population/SegmentGroup.js

@@ -0,0 +1,44 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentGroup = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const SegmentConditionKindEnum_1 = require("../../enums/SegmentConditionKindEnum");
+const SegmentMatchEnum_1 = require("../../enums/SegmentMatchEnum");
+const SegmentAggregateCondition_1 = require("./SegmentAggregateCondition");
+const SegmentColumnCondition_1 = require("./SegmentColumnCondition");
+class SegmentGroup {
+}
+exports.SegmentGroup = SegmentGroup;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsEnum)(SegmentMatchEnum_1.SegmentMatchEnum),
+    __metadata("design:type", String)
+], SegmentGroup.prototype, "match", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsArray)(),
+    (0, class_validator_1.ArrayMinSize)(1),
+    (0, class_validator_1.ArrayMaxSize)(20),
+    (0, class_validator_1.ValidateNested)({ each: true }),
+    (0, class_transformer_1.Type)(() => Object, {
+        keepDiscriminatorProperty: true,
+        discriminator: {
+            property: 'kind',
+            subTypes: [
+                { value: SegmentColumnCondition_1.SegmentColumnCondition, name: SegmentConditionKindEnum_1.SegmentConditionKindEnum.COLUMN },
+                { value: SegmentAggregateCondition_1.SegmentAggregateCondition, name: SegmentConditionKindEnum_1.SegmentConditionKindEnum.AGGREGATE },
+            ],
+        },
+    }),
+    __metadata("design:type", Array)
+], SegmentGroup.prototype, "conditions", void 0);

package/bin/rules/dtos/population/SegmentParam.d.ts

@@ -0,0 +1,10 @@
+import { SegmentParamSourceEnum } from '../../enums/SegmentParamSourceEnum';
+import { SegmentParamTypeEnum } from '../../enums/SegmentParamTypeEnum';
+/** Un `?` del SQL, en orden. LITERAL lleva `value` como texto canonico; REFERENCE_AT_MINUS_DAYS lleva `days`. */
+export declare class SegmentParam {
+    name: string;
+    type: SegmentParamTypeEnum;
+    source: SegmentParamSourceEnum;
+    value?: string;
+    days?: number;
+}

package/bin/rules/dtos/population/SegmentParam.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentParam = void 0;
+/** Un `?` del SQL, en orden. LITERAL lleva `value` como texto canonico; REFERENCE_AT_MINUS_DAYS lleva `days`. */
+class SegmentParam {
+}
+exports.SegmentParam = SegmentParam;

package/bin/rules/dtos/population/SegmentSchemaResponse.d.ts

@@ -0,0 +1,10 @@
+export declare class SegmentSchemaTableResponse {
+    table: string;
+    joinKey: string;
+    columnCount: number;
+}
+/** `available: false` = ambiente sin datalake accesible: el constructor muestra "no disponible". */
+export declare class SegmentSchemaResponse {
+    available: boolean;
+    tables: SegmentSchemaTableResponse[];
+}

package/bin/rules/dtos/population/SegmentSchemaResponse.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentSchemaResponse = exports.SegmentSchemaTableResponse = void 0;
+class SegmentSchemaTableResponse {
+}
+exports.SegmentSchemaTableResponse = SegmentSchemaTableResponse;
+/** `available: false` = ambiente sin datalake accesible: el constructor muestra "no disponible". */
+class SegmentSchemaResponse {
+}
+exports.SegmentSchemaResponse = SegmentSchemaResponse;

package/bin/rules/dtos/population/SegmentTableSchemaResponse.d.ts

@@ -0,0 +1,12 @@
+import { SegmentOperatorEnum } from '../../enums/SegmentOperatorEnum';
+export declare class SegmentColumnSchemaResponse {
+    name: string;
+    type: string;
+    isDate: boolean;
+    operators: SegmentOperatorEnum[];
+}
+export declare class SegmentTableSchemaResponse {
+    table: string;
+    joinKey: string;
+    columns: SegmentColumnSchemaResponse[];
+}

package/bin/rules/dtos/population/SegmentTableSchemaResponse.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentTableSchemaResponse = exports.SegmentColumnSchemaResponse = void 0;
+class SegmentColumnSchemaResponse {
+}
+exports.SegmentColumnSchemaResponse = SegmentColumnSchemaResponse;
+class SegmentTableSchemaResponse {
+}
+exports.SegmentTableSchemaResponse = SegmentTableSchemaResponse;

package/bin/rules/dtos/population/SegmentUsedColumn.d.ts

@@ -0,0 +1,5 @@
+export declare class SegmentUsedColumn {
+    table: string;
+    column: string;
+    type: string;
+}

package/bin/rules/dtos/population/SegmentUsedColumn.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentUsedColumn = void 0;
+class SegmentUsedColumn {
+}
+exports.SegmentUsedColumn = SegmentUsedColumn;

package/bin/rules/dtos/population/SegmentWindow.d.ts

@@ -0,0 +1,5 @@
+/** Ventana relativa [referenceAt - days, referenceAt) sobre una columna de fecha (A§4.1). */
+export declare class SegmentWindow {
+    dateColumn: string;
+    days: number;
+}

package/bin/rules/dtos/population/SegmentWindow.js

@@ -0,0 +1,31 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentWindow = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const SegmentLimits_1 = require("../../constants/SegmentLimits");
+/** Ventana relativa [referenceAt - days, referenceAt) sobre una columna de fecha (A§4.1). */
+class SegmentWindow {
+}
+exports.SegmentWindow = SegmentWindow;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.Matches)(SegmentLimits_1.SEGMENT_IDENTIFIER_PATTERN),
+    __metadata("design:type", String)
+], SegmentWindow.prototype, "dateColumn", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsInt)(),
+    (0, class_validator_1.Min)(1),
+    (0, class_validator_1.Max)(SegmentLimits_1.SEGMENT_MAX_DAYS),
+    __metadata("design:type", Number)
+], SegmentWindow.prototype, "days", void 0);

package/bin/rules/enums/PopulationErrorCodeEnum.d.ts

@@ -0,0 +1,12 @@
+/** Codigos de error del canal de poblacion. Los 8 primeros coinciden con SegmentErrorCodeEnum. */
+export declare enum PopulationErrorCodeEnum {
+    SEGMENT_INVALID = "SEGMENT_INVALID",
+    SEGMENT_BLOCKED_COLUMN = "SEGMENT_BLOCKED_COLUMN",
+    SEGMENT_SCHEMA_DRIFT = "SEGMENT_SCHEMA_DRIFT",
+    SEGMENT_BYTES_EXCEEDED = "SEGMENT_BYTES_EXCEEDED",
+    SEGMENT_QUERY_FAILED = "SEGMENT_QUERY_FAILED",
+    SEGMENT_DATALAKE_UNAVAILABLE = "SEGMENT_DATALAKE_UNAVAILABLE",
+    SEGMENT_DATALAKE_UNAVAILABLE_IN_ENV = "SEGMENT_DATALAKE_UNAVAILABLE_IN_ENV",
+    SEGMENT_EXECUTION_NOT_FOUND = "SEGMENT_EXECUTION_NOT_FOUND",
+    SEGMENT_NEXT_TOKEN_EXPIRED = "SEGMENT_NEXT_TOKEN_EXPIRED"
+}

package/bin/rules/enums/PopulationErrorCodeEnum.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PopulationErrorCodeEnum = void 0;
+/** Codigos de error del canal de poblacion. Los 8 primeros coinciden con SegmentErrorCodeEnum. */
+var PopulationErrorCodeEnum;
+(function (PopulationErrorCodeEnum) {
+    PopulationErrorCodeEnum["SEGMENT_INVALID"] = "SEGMENT_INVALID";
+    PopulationErrorCodeEnum["SEGMENT_BLOCKED_COLUMN"] = "SEGMENT_BLOCKED_COLUMN";
+    PopulationErrorCodeEnum["SEGMENT_SCHEMA_DRIFT"] = "SEGMENT_SCHEMA_DRIFT";
+    PopulationErrorCodeEnum["SEGMENT_BYTES_EXCEEDED"] = "SEGMENT_BYTES_EXCEEDED";
+    PopulationErrorCodeEnum["SEGMENT_QUERY_FAILED"] = "SEGMENT_QUERY_FAILED";
+    PopulationErrorCodeEnum["SEGMENT_DATALAKE_UNAVAILABLE"] = "SEGMENT_DATALAKE_UNAVAILABLE";
+    PopulationErrorCodeEnum["SEGMENT_DATALAKE_UNAVAILABLE_IN_ENV"] = "SEGMENT_DATALAKE_UNAVAILABLE_IN_ENV";
+    PopulationErrorCodeEnum["SEGMENT_EXECUTION_NOT_FOUND"] = "SEGMENT_EXECUTION_NOT_FOUND";
+    PopulationErrorCodeEnum["SEGMENT_NEXT_TOKEN_EXPIRED"] = "SEGMENT_NEXT_TOKEN_EXPIRED";
+})(PopulationErrorCodeEnum || (exports.PopulationErrorCodeEnum = PopulationErrorCodeEnum = {}));

package/bin/rules/enums/PopulationExecutionStatusEnum.d.ts

@@ -0,0 +1,6 @@
+export declare enum PopulationExecutionStatusEnum {
+    RUNNING = "RUNNING",
+    SUCCEEDED = "SUCCEEDED",
+    FAILED = "FAILED",
+    CANCELLED = "CANCELLED"
+}

package/bin/rules/enums/PopulationExecutionStatusEnum.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PopulationExecutionStatusEnum = void 0;
+var PopulationExecutionStatusEnum;
+(function (PopulationExecutionStatusEnum) {
+    PopulationExecutionStatusEnum["RUNNING"] = "RUNNING";
+    PopulationExecutionStatusEnum["SUCCEEDED"] = "SUCCEEDED";
+    PopulationExecutionStatusEnum["FAILED"] = "FAILED";
+    PopulationExecutionStatusEnum["CANCELLED"] = "CANCELLED";
+})(PopulationExecutionStatusEnum || (exports.PopulationExecutionStatusEnum = PopulationExecutionStatusEnum = {}));

package/bin/rules/enums/PopulationTestStatusEnum.d.ts

@@ -0,0 +1,5 @@
+export declare enum PopulationTestStatusEnum {
+    RUNNING = "RUNNING",
+    PASSED = "PASSED",
+    FAILED = "FAILED"
+}

package/bin/rules/enums/PopulationTestStatusEnum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PopulationTestStatusEnum = void 0;
+var PopulationTestStatusEnum;
+(function (PopulationTestStatusEnum) {
+    PopulationTestStatusEnum["RUNNING"] = "RUNNING";
+    PopulationTestStatusEnum["PASSED"] = "PASSED";
+    PopulationTestStatusEnum["FAILED"] = "FAILED";
+})(PopulationTestStatusEnum || (exports.PopulationTestStatusEnum = PopulationTestStatusEnum = {}));

package/bin/rules/enums/SegmentAggregateFnEnum.d.ts

@@ -0,0 +1,5 @@
+export declare enum SegmentAggregateFnEnum {
+    EXISTS = "EXISTS",
+    COUNT = "COUNT",
+    SUM = "SUM"
+}

package/bin/rules/enums/SegmentAggregateFnEnum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentAggregateFnEnum = void 0;
+var SegmentAggregateFnEnum;
+(function (SegmentAggregateFnEnum) {
+    SegmentAggregateFnEnum["EXISTS"] = "EXISTS";
+    SegmentAggregateFnEnum["COUNT"] = "COUNT";
+    SegmentAggregateFnEnum["SUM"] = "SUM";
+})(SegmentAggregateFnEnum || (exports.SegmentAggregateFnEnum = SegmentAggregateFnEnum = {}));

package/bin/rules/enums/SegmentConditionKindEnum.d.ts

@@ -0,0 +1,4 @@
+export declare enum SegmentConditionKindEnum {
+    COLUMN = "COLUMN",
+    AGGREGATE = "AGGREGATE"
+}

package/bin/rules/enums/SegmentConditionKindEnum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentConditionKindEnum = void 0;
+var SegmentConditionKindEnum;
+(function (SegmentConditionKindEnum) {
+    SegmentConditionKindEnum["COLUMN"] = "COLUMN";
+    SegmentConditionKindEnum["AGGREGATE"] = "AGGREGATE";
+})(SegmentConditionKindEnum || (exports.SegmentConditionKindEnum = SegmentConditionKindEnum = {}));

package/bin/rules/enums/SegmentMatchEnum.d.ts

@@ -0,0 +1,4 @@
+export declare enum SegmentMatchEnum {
+    ALL = "ALL",
+    ANY = "ANY"
+}

package/bin/rules/enums/SegmentMatchEnum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentMatchEnum = void 0;
+var SegmentMatchEnum;
+(function (SegmentMatchEnum) {
+    SegmentMatchEnum["ALL"] = "ALL";
+    SegmentMatchEnum["ANY"] = "ANY";
+})(SegmentMatchEnum || (exports.SegmentMatchEnum = SegmentMatchEnum = {}));

package/bin/rules/enums/SegmentOperatorEnum.d.ts

@@ -0,0 +1,16 @@
+export declare enum SegmentOperatorEnum {
+    EQUALS = "EQUALS",
+    NOT_EQUALS = "NOT_EQUALS",
+    IN = "IN",
+    NOT_IN = "NOT_IN",
+    IS_NULL = "IS_NULL",
+    IS_NOT_NULL = "IS_NOT_NULL",
+    GT = "GT",
+    GTE = "GTE",
+    LT = "LT",
+    LTE = "LTE",
+    CONTAINS = "CONTAINS",
+    ANY_IN = "ANY_IN",
+    WITHIN_LAST_DAYS = "WITHIN_LAST_DAYS",
+    NOT_WITHIN_LAST_DAYS = "NOT_WITHIN_LAST_DAYS"
+}

package/bin/rules/enums/SegmentOperatorEnum.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentOperatorEnum = void 0;
+var SegmentOperatorEnum;
+(function (SegmentOperatorEnum) {
+    SegmentOperatorEnum["EQUALS"] = "EQUALS";
+    SegmentOperatorEnum["NOT_EQUALS"] = "NOT_EQUALS";
+    SegmentOperatorEnum["IN"] = "IN";
+    SegmentOperatorEnum["NOT_IN"] = "NOT_IN";
+    SegmentOperatorEnum["IS_NULL"] = "IS_NULL";
+    SegmentOperatorEnum["IS_NOT_NULL"] = "IS_NOT_NULL";
+    SegmentOperatorEnum["GT"] = "GT";
+    SegmentOperatorEnum["GTE"] = "GTE";
+    SegmentOperatorEnum["LT"] = "LT";
+    SegmentOperatorEnum["LTE"] = "LTE";
+    SegmentOperatorEnum["CONTAINS"] = "CONTAINS";
+    SegmentOperatorEnum["ANY_IN"] = "ANY_IN";
+    SegmentOperatorEnum["WITHIN_LAST_DAYS"] = "WITHIN_LAST_DAYS";
+    SegmentOperatorEnum["NOT_WITHIN_LAST_DAYS"] = "NOT_WITHIN_LAST_DAYS";
+})(SegmentOperatorEnum || (exports.SegmentOperatorEnum = SegmentOperatorEnum = {}));

package/bin/rules/enums/SegmentParamSourceEnum.d.ts

@@ -0,0 +1,5 @@
+export declare enum SegmentParamSourceEnum {
+    LITERAL = "LITERAL",
+    REFERENCE_AT = "REFERENCE_AT",
+    REFERENCE_AT_MINUS_DAYS = "REFERENCE_AT_MINUS_DAYS"
+}

package/bin/rules/enums/SegmentParamSourceEnum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentParamSourceEnum = void 0;
+var SegmentParamSourceEnum;
+(function (SegmentParamSourceEnum) {
+    SegmentParamSourceEnum["LITERAL"] = "LITERAL";
+    SegmentParamSourceEnum["REFERENCE_AT"] = "REFERENCE_AT";
+    SegmentParamSourceEnum["REFERENCE_AT_MINUS_DAYS"] = "REFERENCE_AT_MINUS_DAYS";
+})(SegmentParamSourceEnum || (exports.SegmentParamSourceEnum = SegmentParamSourceEnum = {}));

package/bin/rules/enums/SegmentParamTypeEnum.d.ts

@@ -0,0 +1,7 @@
+export declare enum SegmentParamTypeEnum {
+    STRING = "STRING",
+    INTEGER = "INTEGER",
+    DECIMAL = "DECIMAL",
+    BOOLEAN = "BOOLEAN",
+    TIMESTAMP = "TIMESTAMP"
+}

package/bin/rules/enums/SegmentParamTypeEnum.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentParamTypeEnum = void 0;
+var SegmentParamTypeEnum;
+(function (SegmentParamTypeEnum) {
+    SegmentParamTypeEnum["STRING"] = "STRING";
+    SegmentParamTypeEnum["INTEGER"] = "INTEGER";
+    SegmentParamTypeEnum["DECIMAL"] = "DECIMAL";
+    SegmentParamTypeEnum["BOOLEAN"] = "BOOLEAN";
+    SegmentParamTypeEnum["TIMESTAMP"] = "TIMESTAMP";
+})(SegmentParamTypeEnum || (exports.SegmentParamTypeEnum = SegmentParamTypeEnum = {}));

package/bin/rules/index.d.ts

@@ -13,3 +13,29 @@ export * from './dtos/GenerateRulesResponse';
 export * from './dtos/RulesTraceResponse';
 export * from './dtos/EvaluateRulesRequest';
 export * from './dtos/EvaluateRulesResponse';
+export * from './enums/SegmentMatchEnum';
+export * from './enums/SegmentConditionKindEnum';
+export * from './enums/SegmentAggregateFnEnum';
+export * from './enums/SegmentOperatorEnum';
+export * from './enums/SegmentParamTypeEnum';
+export * from './enums/SegmentParamSourceEnum';
+export * from './constants/SegmentLimits';
+export * from './dtos/population/SegmentWindow';
+export * from './dtos/population/SegmentColumnCondition';
+export * from './dtos/population/SegmentAggregateCondition';
+export * from './dtos/population/SegmentGroup';
+export * from './dtos/population/PopulationSegmentDefinition';
+export * from './dtos/population/SegmentParam';
+export * from './dtos/population/SegmentUsedColumn';
+export * from './dtos/population/SegmentSchemaResponse';
+export * from './dtos/population/SegmentTableSchemaResponse';
+export * from './enums/PopulationErrorCodeEnum';
+export * from './enums/PopulationTestStatusEnum';
+export * from './enums/PopulationExecutionStatusEnum';
+export * from './dtos/population/PopulationCompileRequest';
+export * from './dtos/population/PopulationCompileResponse';
+export * from './dtos/population/PopulationTestRequest';
+export * from './dtos/population/PopulationTestResponse';
+export * from './dtos/population/PopulationExecutionRequest';
+export * from './dtos/population/PopulationExecutionResponse';
+export * from './dtos/population/PopulationExecutionPageResponse';

package/bin/rules/index.js

@@ -32,3 +32,31 @@ __exportStar(require("./dtos/GenerateRulesResponse"), exports);
 __exportStar(require("./dtos/RulesTraceResponse"), exports);
 __exportStar(require("./dtos/EvaluateRulesRequest"), exports);
 __exportStar(require("./dtos/EvaluateRulesResponse"), exports);
+//Poblacion (movido desde rewardsEligibility; alli queda re-export)
+__exportStar(require("./enums/SegmentMatchEnum"), exports);
+__exportStar(require("./enums/SegmentConditionKindEnum"), exports);
+__exportStar(require("./enums/SegmentAggregateFnEnum"), exports);
+__exportStar(require("./enums/SegmentOperatorEnum"), exports);
+__exportStar(require("./enums/SegmentParamTypeEnum"), exports);
+__exportStar(require("./enums/SegmentParamSourceEnum"), exports);
+__exportStar(require("./constants/SegmentLimits"), exports);
+__exportStar(require("./dtos/population/SegmentWindow"), exports);
+__exportStar(require("./dtos/population/SegmentColumnCondition"), exports);
+__exportStar(require("./dtos/population/SegmentAggregateCondition"), exports);
+__exportStar(require("./dtos/population/SegmentGroup"), exports);
+__exportStar(require("./dtos/population/PopulationSegmentDefinition"), exports);
+__exportStar(require("./dtos/population/SegmentParam"), exports);
+__exportStar(require("./dtos/population/SegmentUsedColumn"), exports);
+__exportStar(require("./dtos/population/SegmentSchemaResponse"), exports);
+__exportStar(require("./dtos/population/SegmentTableSchemaResponse"), exports);
+//Poblacion: endpoints del canal /population/*
+__exportStar(require("./enums/PopulationErrorCodeEnum"), exports);
+__exportStar(require("./enums/PopulationTestStatusEnum"), exports);
+__exportStar(require("./enums/PopulationExecutionStatusEnum"), exports);
+__exportStar(require("./dtos/population/PopulationCompileRequest"), exports);
+__exportStar(require("./dtos/population/PopulationCompileResponse"), exports);
+__exportStar(require("./dtos/population/PopulationTestRequest"), exports);
+__exportStar(require("./dtos/population/PopulationTestResponse"), exports);
+__exportStar(require("./dtos/population/PopulationExecutionRequest"), exports);
+__exportStar(require("./dtos/population/PopulationExecutionResponse"), exports);
+__exportStar(require("./dtos/population/PopulationExecutionPageResponse"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fiado/type-kit",
-  "version": "3.540.0",
+  "version": "3.541.0",
   "description": "",
   "main": "bin/index.js",
   "types": "bin/index.d.ts",

package/src/rewardsEligibility/constants/SegmentLimits.ts

@@ -1,5 +1 @@
-/** Identificador SQL permitido para tabla/columna (A§4.3 paso 1): minusculas, digitos y guion bajo; nunca texto libre. */
-export const SEGMENT_IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_]*$/;
-export const SEGMENT_MAX_DAYS = 365;
-export const SEGMENT_MAX_PARAMS = 40;
-export const SEGMENT_MAX_AGGREGATES = 8;
+export * from '../../rules/constants/SegmentLimits';

package/src/rewardsEligibility/dtos/backoffice/segments/PopulationSegmentDefinition.ts

@@ -1,12 +1 @@
-import { Expose, Type } from 'class-transformer';
-import { ArrayMaxSize, ArrayMinSize, IsArray, IsEnum, Matches, ValidateNested } from 'class-validator';
-import { SEGMENT_IDENTIFIER_PATTERN } from '../../../constants/SegmentLimits';
-import { SegmentMatchEnum } from '../../../enums/SegmentMatchEnum';
-import { SegmentGroup } from './SegmentGroup';
-
-/** El constructor tal cual (A§4.1): tabla ancla (una fila -> un directoryid), TODAS/ALGUNA global y grupos con su propio TODAS/ALGUNA. */
-export class PopulationSegmentDefinition {
-    @Expose() @Matches(SEGMENT_IDENTIFIER_PATTERN) baseTable: string;
-    @Expose() @IsEnum(SegmentMatchEnum) match: SegmentMatchEnum;
-    @Expose() @IsArray() @ArrayMinSize(1) @ArrayMaxSize(10) @ValidateNested({ each: true }) @Type(() => SegmentGroup) groups: SegmentGroup[];
-}
+export * from '../../../../rules/dtos/population/PopulationSegmentDefinition';

package/src/rewardsEligibility/dtos/backoffice/segments/SegmentAggregateCondition.ts

@@ -1,22 +1 @@
-import { Expose, Type } from 'class-transformer';
-import { ArrayMaxSize, Equals, IsArray, IsEnum, IsNumber, IsOptional, Matches, ValidateNested } from 'class-validator';
-import { SEGMENT_IDENTIFIER_PATTERN } from '../../../constants/SegmentLimits';
-import { SegmentAggregateFnEnum } from '../../../enums/SegmentAggregateFnEnum';
-import { SegmentConditionKindEnum } from '../../../enums/SegmentConditionKindEnum';
-import { SegmentOperatorEnum } from '../../../enums/SegmentOperatorEnum';
-import { SegmentColumnCondition } from './SegmentColumnCondition';
-import { SegmentWindow } from './SegmentWindow';
-
-/** (b) Agregado con ventana relativa sobre una tabla relacionada (existe / cuenta / suma). `filters` elige QUE cuenta (estados, moneda...). */
-export class SegmentAggregateCondition {
-    @Expose() @Equals(SegmentConditionKindEnum.AGGREGATE) kind: SegmentConditionKindEnum.AGGREGATE;
-    @Expose() @Matches(SEGMENT_IDENTIFIER_PATTERN) table: string;
-    @Expose() @IsEnum(SegmentAggregateFnEnum) fn: SegmentAggregateFnEnum;
-    /** Solo SUM. */
-    @Expose() @IsOptional() @Matches(SEGMENT_IDENTIFIER_PATTERN) column?: string;
-    /** COUNT y SUM; EXISTS no lleva. */
-    @Expose() @IsOptional() @IsEnum(SegmentOperatorEnum) op?: SegmentOperatorEnum;
-    @Expose() @IsOptional() @IsNumber() value?: number;
-    @Expose() @ValidateNested() @Type(() => SegmentWindow) window: SegmentWindow;
-    @Expose() @IsArray() @ArrayMaxSize(10) @ValidateNested({ each: true }) @Type(() => SegmentColumnCondition) filters: SegmentColumnCondition[];
-}
+export * from '../../../../rules/dtos/population/SegmentAggregateCondition';