@fiado/type-kit 3.499.0 → 3.501.0

package/_test_/unit/cognitoBackofficeConnector/dtos/AuthStartLogin.test.ts

@@ -0,0 +1,76 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { AuthStartLoginRequest } from '../../../../src/cognitoBackofficeConnector/dtos/AuthStartLoginRequest';
+import {
+    AuthStartLoginResponse,
+    AuthStartLoginTokens,
+} from '../../../../src/cognitoBackofficeConnector/dtos/AuthStartLoginResponse';
+import { CognitoChallengeType } from '../../../../src/cognitoBackofficeConnector/enums/CognitoChallengeType';
+
+describe('AuthStartLoginRequest', () => {
+    const base = {
+        userPoolId: 'us-east-1_abc',
+        region: 'us-east-1',
+        clientId: 'client-123',
+        username: 'sub-123',
+        password: 'Secret123!',
+    };
+
+    it('valida happy path', async () => {
+        const dto = plainToInstance(AuthStartLoginRequest, base);
+        expect(await validate(dto)).toEqual([]);
+    });
+
+    it('falla si falta password', async () => {
+        const dto = plainToInstance(AuthStartLoginRequest, { ...base, password: '' });
+        expect((await validate(dto)).some((e) => e.property === 'password')).toBe(true);
+    });
+
+    it('falla si clientId no es string', async () => {
+        const dto = plainToInstance(AuthStartLoginRequest, { ...base, clientId: 42 });
+        expect((await validate(dto)).some((e) => e.property === 'clientId')).toBe(true);
+    });
+});
+
+describe('AuthStartLoginResponse', () => {
+    it('tokens directos (2FA apagado)', async () => {
+        const dto = plainToInstance(AuthStartLoginResponse, {
+            tokens: {
+                accessToken: 'a',
+                idToken: 'i',
+                refreshToken: 'r',
+                expiresIn: 3600,
+                tokenType: 'Bearer',
+            },
+        });
+        expect(await validate(dto)).toEqual([]);
+        expect(dto.tokens).toBeInstanceOf(AuthStartLoginTokens);
+    });
+
+    it('challenge CUSTOM_CHALLENGE + session + parameters', async () => {
+        const dto = plainToInstance(AuthStartLoginResponse, {
+            challengeType: CognitoChallengeType.CUSTOM_CHALLENGE,
+            session: 'sess-123',
+            challengeParameters: { challengeName: 'EMAIL_OTP' },
+        });
+        expect(await validate(dto)).toEqual([]);
+    });
+
+    it('vacio es valido (todos opcionales)', async () => {
+        const dto = plainToInstance(AuthStartLoginResponse, {});
+        expect(await validate(dto)).toEqual([]);
+    });
+
+    it('falla si challengeType no es del enum', async () => {
+        const dto = plainToInstance(AuthStartLoginResponse, { challengeType: 'BOGUS' });
+        expect((await validate(dto)).some((e) => e.property === 'challengeType')).toBe(true);
+    });
+
+    it('falla si expiresIn de tokens no es number', async () => {
+        const dto = plainToInstance(AuthStartLoginResponse, {
+            tokens: { accessToken: 'a', idToken: 'i', refreshToken: 'r', expiresIn: 'x', tokenType: 'Bearer' },
+        });
+        expect((await validate(dto)).length).toBeGreaterThan(0);
+    });
+});

package/_test_/unit/platformRbac/auth/dtos.test.ts

@@ -39,4 +39,37 @@ describe('DefineNextChallengeRequest', () => {
         expect(errors.length).toBeGreaterThan(0);
         expect(errors[0].property).toBe('cognitoSub');
     });
+
+    it('acepta userStatus opcional (cognito:user_status, C-06)', async () => {
+        const dto = plainToInstance(DefineNextChallengeRequest, {
+            cognitoSub: 'abc-123',
+            userNotFound: false,
+            session: [],
+            userStatus: 'FORCE_CHANGE_PASSWORD',
+        });
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+        expect(dto.userStatus).toBe('FORCE_CHANGE_PASSWORD');
+    });
+
+    it('userStatus ausente sigue siendo valido (aditivo)', async () => {
+        const dto = plainToInstance(DefineNextChallengeRequest, {
+            cognitoSub: 'abc-123',
+            userNotFound: false,
+            session: [],
+        });
+        expect(await validate(dto)).toEqual([]);
+        expect(dto.userStatus).toBeUndefined();
+    });
+
+    it('falla si userStatus no es string', async () => {
+        const dto = plainToInstance(DefineNextChallengeRequest, {
+            cognitoSub: 'abc-123',
+            userNotFound: false,
+            session: [],
+            userStatus: 99,
+        });
+        const errors = await validate(dto);
+        expect(errors.some((e) => e.property === 'userStatus')).toBe(true);
+    });
 });

package/_test_/unit/platformRbac/enums/ChallengeNameEnum.test.ts

@@ -0,0 +1,17 @@
+import { ChallengeNameEnum } from '../../../../src/platformRbac/enums/ChallengeNameEnum';
+
+describe('ChallengeNameEnum', () => {
+    it('incluye SRP_A y PASSWORD_VERIFIER (SRP dentro de CUSTOM_AUTH)', () => {
+        expect(ChallengeNameEnum.SRP_A).toBe('SRP_A');
+        expect(ChallengeNameEnum.PASSWORD_VERIFIER).toBe('PASSWORD_VERIFIER');
+    });
+
+    it('conserva los valores previos', () => {
+        expect(ChallengeNameEnum.PASSWORD).toBe('PASSWORD');
+        expect(ChallengeNameEnum.EMAIL_OTP).toBe('EMAIL_OTP');
+        expect(ChallengeNameEnum.TOTP).toBe('TOTP');
+        expect(ChallengeNameEnum.NEW_PASSWORD_REQUIRED).toBe('NEW_PASSWORD_REQUIRED');
+        expect(ChallengeNameEnum.RESET_PASSWORD).toBe('RESET_PASSWORD');
+        expect(ChallengeNameEnum.SMS_OTP).toBe('SMS_OTP');
+    });
+});

package/_test_/unit/retailPromotions/constants.test.ts

@@ -43,7 +43,7 @@ describe('catálogo de errores', () => {
     expect(RETAIL_PROMOTIONS_ERROR_HTTP_STATUS.CODE_NOT_FOUND).toBe(404);
     expect(RETAIL_PROMOTIONS_ERROR_HTTP_STATUS.DISCOUNT_AFTER_QUOTE).toBe(409);
     expect(RETAIL_PROMOTIONS_ERROR_HTTP_STATUS.CODE_NOT_OWNED).toBe(422);
-    expect(Object.keys(RetailPromotionsErrorCodeEnum)).toHaveLength(30);
+    expect(Object.keys(RetailPromotionsErrorCodeEnum)).toHaveLength(31);
     expect(RETAIL_PROMOTIONS_ERROR_HTTP_STATUS.SPLIT_FINANCING_DISABLED).toBe(409);
   });
 

package/_test_/unit/retailPromotions/evaluatedSalePromotion.test.ts

@@ -19,6 +19,8 @@ const basePromotion: EvaluatedSalePromotion = {
   giftChooseCount: null,
   afterSale: [],
   appliesTo: PromotionAppliesToEnum.SUREKEEP_ONLY,
+  stackable: false,
+  anchorBound: false,
 };
 
 describe('EvaluatedSalePromotion.blockedBy', () => {

package/_test_/unit/retailPromotions/resolveSalePromotionKind.test.ts

@@ -42,6 +42,8 @@ describe('EvaluatedSalePromotion.kind', () => {
       giftChooseCount: 1,
       afterSale: [],
       appliesTo: PromotionAppliesToEnum.SUREKEEP_ONLY,
+      stackable: false,
+      anchorBound: false,
     };
     expect(promotion.kind).toBe(SalePromotionKindEnum.GIFT);
   });

package/_test_/unit/retailPromotions/salePromotionConditions.test.ts

@@ -16,6 +16,8 @@ const storeItem: StoreSalePromotionItem = {
   levers: { gift: null, deviceDiscount: null, accessoryDiscount: null, coupon: null, walletBonus: null, extendedWarranty: null, airtime: null },
   scope: { storeIds: null, productCategories: null, tiers: null, skus: null },
   appliesTo: PromotionAppliesToEnum.ANY_FINANCIER,
+  stackable: false,
+  anchorBound: false,
 };
 
 const evaluated: EvaluatedSalePromotion = {
@@ -31,6 +33,8 @@ const evaluated: EvaluatedSalePromotion = {
   giftChooseCount: null,
   afterSale: [],
   appliesTo: PromotionAppliesToEnum.SUREKEEP_ONLY,
+  stackable: false,
+  anchorBound: false,
 };
 
 describe('SalePromotionConditions', () => {

package/_test_/unit/retailPromotions/stackablePromotions.test.ts

@@ -0,0 +1,238 @@
+import 'reflect-metadata';
+import { plainToInstance, type ClassConstructor } from 'class-transformer';
+import { validateSync, type ValidationError } from 'class-validator';
+import {
+  CreateSalePromotionRequest,
+  HoldPromotionInput,
+  HoldSalePromotionRequest,
+  LinePromotionAmount,
+  RETAIL_PROMOTIONS_ERROR_HTTP_STATUS,
+  RetailPromotionsErrorCodeEnum,
+  SalePromotionKindEnum,
+  SalePromotionRef,
+  UpdateSalePromotionRequest,
+  type HeldPromotion,
+  type HoldSalePromotionResponse,
+  type LinePromotionDiscount,
+} from '../../../src/retailPromotions/index';
+import {
+  ApplyLinePromotionRequest,
+  ApplySalePromotionRequest,
+  RetailPromotionInboundMessage,
+  RetailPromotionInboundMessageTypeEnum,
+  LinePromotionAmount as WizardLinePromotionAmount,
+  SalePromotionRef as WizardSalePromotionRef,
+  type WizardLinePromotionFields,
+} from '../../../src/retailWizard';
+
+function paths(errors: ValidationError[], prefix = ''): string[] {
+  return errors.flatMap((e) => {
+    const p = prefix ? `${prefix}.${e.property}` : e.property;
+    return e.children && e.children.length > 0 ? paths(e.children, p) : [p];
+  });
+}
+
+function errorsOf<T extends object>(cls: ClassConstructor<T>, payload: object): string[] {
+  return paths(validateSync(plainToInstance(cls, payload) as object));
+}
+
+const amount = { promotionId: 'P1', promotionVersion: 1, discountCents: 5000 };
+
+describe('stackable en el CRUD de promos', () => {
+  const create = { name: 'Promo', customerText: 'Texto', levers: {} };
+
+  it('acepta stackable booleano o ausente', () => {
+    expect(errorsOf(CreateSalePromotionRequest, { ...create, stackable: true })).not.toContain('stackable');
+    expect(errorsOf(CreateSalePromotionRequest, create)).not.toContain('stackable');
+    expect(errorsOf(UpdateSalePromotionRequest, { stackable: false })).toEqual([]);
+  });
+
+  it('rechaza stackable que no es booleano', () => {
+    expect(errorsOf(CreateSalePromotionRequest, { ...create, stackable: 'si' })).toContain('stackable');
+    expect(errorsOf(UpdateSalePromotionRequest, { stackable: 1 })).toContain('stackable');
+  });
+});
+
+describe('HoldSalePromotionRequest.promotions', () => {
+  const promotions = [
+    { promotionId: 'P1', promotionVersion: 2, lineIds: ['L1'], giftSkus: ['SKU-1'] },
+    { promotionId: 'P2', promotionVersion: 1 },
+  ];
+
+  it('acepta la lista nueva sola, con o sin código', () => {
+    expect(errorsOf(HoldSalePromotionRequest, { promotions })).toEqual([]);
+    expect(errorsOf(HoldSalePromotionRequest, { promotions, discountCode: 'BUENFIN' })).toEqual([]);
+  });
+
+  it('sigue aceptando la forma vieja sola', () => {
+    expect(
+      errorsOf(HoldSalePromotionRequest, {
+        gift: { promotionId: 'G1', promotionVersion: 1, skus: ['SKU-1'] },
+        promotionId: 'P1',
+        promotionVersion: 1,
+        saleGiftSkus: ['SKU-2'],
+      }),
+    ).toEqual([]);
+  });
+
+  it.each([
+    ['gift', { gift: { promotionId: 'G1', promotionVersion: 1, skus: ['SKU-1'] } }],
+    ['promotionId', { promotionId: 'P1', promotionVersion: 1 }],
+    ['saleGiftSkus', { saleGiftSkus: ['SKU-2'] }],
+  ])('rechaza mezclar promotions con %s', (_field, legacy) => {
+    expect(errorsOf(HoldSalePromotionRequest, { promotions, ...legacy })).toContain('promotions');
+  });
+
+  it('valida cada elemento anidado', () => {
+    const found = errorsOf(HoldSalePromotionRequest, {
+      promotions: [{ promotionId: '', promotionVersion: 0, lineIds: [''], giftSkus: 'SKU' }],
+    });
+    expect(found).toEqual(
+      expect.arrayContaining([
+        'promotions.0.promotionId',
+        'promotions.0.promotionVersion',
+        'promotions.0.lineIds',
+        'promotions.0.giftSkus',
+      ]),
+    );
+  });
+
+  it('HoldPromotionInput se valida solo', () => {
+    expect(errorsOf(HoldPromotionInput, { promotionId: 'P1', promotionVersion: 1 })).toEqual([]);
+  });
+});
+
+describe('promotionDiscounts por línea', () => {
+  it('ApplyLinePromotionRequest acepta la lista y el descuento del código', () => {
+    expect(
+      errorsOf(ApplyLinePromotionRequest, {
+        promotionId: 'P1',
+        promotionVersion: 1,
+        discountCents: 7000,
+        codeDiscountCents: 2000,
+        promotionDiscounts: [amount],
+      }),
+    ).toEqual([]);
+  });
+
+  it('ApplyLinePromotionRequest valida la lista anidada y el código negativo', () => {
+    const found = errorsOf(ApplyLinePromotionRequest, {
+      codeDiscountCents: -1,
+      promotionDiscounts: [{ promotionId: '', promotionVersion: 0, discountCents: -5 }],
+    });
+    expect(found).toEqual(
+      expect.arrayContaining([
+        'codeDiscountCents',
+        'promotionDiscounts.0.promotionId',
+        'promotionDiscounts.0.promotionVersion',
+        'promotionDiscounts.0.discountCents',
+      ]),
+    );
+  });
+
+  it('LinePromotionAmount es la misma clase en ambos módulos', () => {
+    expect(WizardLinePromotionAmount).toBe(LinePromotionAmount);
+    expect(errorsOf(LinePromotionAmount, amount)).toEqual([]);
+  });
+
+  it('las interfaces aceptan la lista por promo', () => {
+    const fields: WizardLinePromotionFields = { promotionDiscounts: [amount], codeDiscountCents: 0 };
+    const discount: LinePromotionDiscount = {
+      lineId: 'L1',
+      promotionId: 'P1',
+      promotionVersion: 1,
+      discountCode: null,
+      originalPriceCents: 10000,
+      discountCents: 5000,
+      finalPriceCents: 5000,
+      promotionDiscounts: [amount],
+      codeDiscountCents: 0,
+    };
+    expect(fields.promotionDiscounts).toEqual(discount.promotionDiscounts);
+  });
+});
+
+describe('salePromotions por venta', () => {
+  const ref = { promotionId: 'P1', promotionVersion: 1 };
+
+  it('ApplySalePromotionRequest acepta la lista y la valida anidada', () => {
+    const base = { salePromotionId: null, salePromotionVersion: null };
+    expect(errorsOf(ApplySalePromotionRequest, { ...base, salePromotions: [ref] })).toEqual([]);
+    expect(errorsOf(ApplySalePromotionRequest, { ...base, salePromotions: null })).toEqual([]);
+    expect(
+      errorsOf(ApplySalePromotionRequest, { ...base, salePromotions: [{ promotionId: '', promotionVersion: 0 }] }),
+    ).toEqual(expect.arrayContaining(['salePromotions.0.promotionId', 'salePromotions.0.promotionVersion']));
+  });
+
+  it('SalePromotionRef es la misma clase en ambos módulos', () => {
+    expect(WizardSalePromotionRef).toBe(SalePromotionRef);
+  });
+
+  it('RetailPromotionInboundMessage valida salePromotions y promotionDiscounts de la línea', () => {
+    const message = {
+      type: RetailPromotionInboundMessageTypeEnum.SALE_CONFIRMED,
+      tenantId: 'T',
+      retailerId: 'R',
+      storeId: 'S',
+      saleId: 'V',
+      sessionId: 'W',
+      customerId: 'C',
+      soldAt: '2026-10-06T00:00:00.000Z',
+      occurredAt: '2026-10-06T00:00:00.000Z',
+      salePromotions: [ref],
+      lines: [
+        {
+          lineId: 'L1',
+          sku: 'SKU',
+          qty: 1,
+          originalPriceCents: 10000,
+          identifiers: [],
+          promotionDiscounts: [amount],
+          codeDiscountCents: 0,
+        },
+      ],
+    };
+    expect(errorsOf(RetailPromotionInboundMessage, message)).toEqual([]);
+    const bad = {
+      ...message,
+      salePromotions: [{ promotionId: 'P1' }],
+      lines: [{ ...message.lines[0], promotionDiscounts: [{ ...amount, discountCents: 'x' }], codeDiscountCents: -1 }],
+    };
+    expect(errorsOf(RetailPromotionInboundMessage, bad)).toEqual(
+      expect.arrayContaining([
+        'salePromotions.0.promotionVersion',
+        'lines.0.promotionDiscounts.0.discountCents',
+        'lines.0.codeDiscountCents',
+      ]),
+    );
+  });
+});
+
+describe('respuesta del apartado y error nuevo', () => {
+  it('HoldSalePromotionResponse trae promotions sin quitar los campos viejos', () => {
+    const held: HeldPromotion = {
+      promotionId: 'P1',
+      promotionVersion: 1,
+      kind: SalePromotionKindEnum.SALE,
+      stackable: true,
+      lineIds: ['L1'],
+      giftSkus: [],
+    };
+    const response: HoldSalePromotionResponse = {
+      sessionId: 'W',
+      gift: null,
+      promotionId: null,
+      promotionVersion: null,
+      discountCode: null,
+      saleGiftSkus: [],
+      lines: [],
+      totalDiscountCents: 0,
+      promotions: [held],
+    };
+    expect(response.promotions).toHaveLength(1);
+  });
+
+  it('PROMOTION_NOT_STACKABLE responde 422', () => {
+    expect(RETAIL_PROMOTIONS_ERROR_HTTP_STATUS[RetailPromotionsErrorCodeEnum.PROMOTION_NOT_STACKABLE]).toBe(422);
+  });
+});

package/bin/cognitoBackofficeConnector/dtos/AuthStartLoginRequest.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Request del login de un solo flujo (SRP dentro de CUSTOM_AUTH). El connector
+ * hace InitiateAuth(CUSTOM_AUTH, CHALLENGE_NAME=SRP_A) y responde PASSWORD_VERIFIER
+ * firmado en la misma operacion. La contraseña nunca viaja en claro a Cognito: SRP
+ * la convierte en prueba. El caller (rbac) no conoce el mecanismo.
+ */
+export declare class AuthStartLoginRequest {
+    userPoolId: string;
+    region: string;
+    clientId: string;
+    username: string;
+    password: string;
+}

package/bin/cognitoBackofficeConnector/dtos/AuthStartLoginRequest.js

@@ -0,0 +1,53 @@
+"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.AuthStartLoginRequest = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+/**
+ * Request del login de un solo flujo (SRP dentro de CUSTOM_AUTH). El connector
+ * hace InitiateAuth(CUSTOM_AUTH, CHALLENGE_NAME=SRP_A) y responde PASSWORD_VERIFIER
+ * firmado en la misma operacion. La contraseña nunca viaja en claro a Cognito: SRP
+ * la convierte en prueba. El caller (rbac) no conoce el mecanismo.
+ */
+class AuthStartLoginRequest {
+}
+exports.AuthStartLoginRequest = AuthStartLoginRequest;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", String)
+], AuthStartLoginRequest.prototype, "userPoolId", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", String)
+], AuthStartLoginRequest.prototype, "region", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", String)
+], AuthStartLoginRequest.prototype, "clientId", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", String)
+], AuthStartLoginRequest.prototype, "username", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", String)
+], AuthStartLoginRequest.prototype, "password", void 0);

package/bin/cognitoBackofficeConnector/dtos/AuthStartLoginResponse.d.ts

@@ -0,0 +1,22 @@
+import { CognitoChallengeType } from '../enums/CognitoChallengeType';
+export declare class AuthStartLoginTokens {
+    accessToken: string;
+    idToken: string;
+    refreshToken: string;
+    expiresIn: number;
+    tokenType: string;
+}
+/**
+ * Respuesta de `authStartLogin`. Tras verificar el password via SRP
+ * (PASSWORD_VERIFIER), Cognito devuelve una de dos cosas: `tokens` si el flujo
+ * quedo completo (2FA apagado), o `challengeType` + `session` + `challengeParameters`
+ * si falta un paso (NEW_PASSWORD_REQUIRED, o el CUSTOM_CHALLENGE del 2do factor con
+ * el sub-challenge real en `challengeParameters.challengeName`). Todos los campos son
+ * opcionales: el caller (rbac) decide por que rama sigue.
+ */
+export declare class AuthStartLoginResponse {
+    tokens?: AuthStartLoginTokens;
+    challengeType?: CognitoChallengeType;
+    session?: string;
+    challengeParameters?: Record<string, string>;
+}

package/bin/cognitoBackofficeConnector/dtos/AuthStartLoginResponse.js

@@ -0,0 +1,79 @@
+"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.AuthStartLoginResponse = exports.AuthStartLoginTokens = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const CognitoChallengeType_1 = require("../enums/CognitoChallengeType");
+class AuthStartLoginTokens {
+}
+exports.AuthStartLoginTokens = AuthStartLoginTokens;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], AuthStartLoginTokens.prototype, "accessToken", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], AuthStartLoginTokens.prototype, "idToken", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], AuthStartLoginTokens.prototype, "refreshToken", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsNumber)(),
+    __metadata("design:type", Number)
+], AuthStartLoginTokens.prototype, "expiresIn", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], AuthStartLoginTokens.prototype, "tokenType", void 0);
+/**
+ * Respuesta de `authStartLogin`. Tras verificar el password via SRP
+ * (PASSWORD_VERIFIER), Cognito devuelve una de dos cosas: `tokens` si el flujo
+ * quedo completo (2FA apagado), o `challengeType` + `session` + `challengeParameters`
+ * si falta un paso (NEW_PASSWORD_REQUIRED, o el CUSTOM_CHALLENGE del 2do factor con
+ * el sub-challenge real en `challengeParameters.challengeName`). Todos los campos son
+ * opcionales: el caller (rbac) decide por que rama sigue.
+ */
+class AuthStartLoginResponse {
+}
+exports.AuthStartLoginResponse = AuthStartLoginResponse;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.ValidateNested)(),
+    (0, class_transformer_1.Type)(() => AuthStartLoginTokens),
+    __metadata("design:type", AuthStartLoginTokens)
+], AuthStartLoginResponse.prototype, "tokens", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsEnum)(CognitoChallengeType_1.CognitoChallengeType),
+    __metadata("design:type", String)
+], AuthStartLoginResponse.prototype, "challengeType", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], AuthStartLoginResponse.prototype, "session", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsObject)(),
+    __metadata("design:type", Object)
+], AuthStartLoginResponse.prototype, "challengeParameters", void 0);

package/bin/cognitoBackofficeConnector/index.d.ts

@@ -21,6 +21,8 @@ export * from './dtos/UserDetailResponse';
 export * from './dtos/AuthEventsRequest';
 export * from './dtos/AuthEventResponse';
 export * from './dtos/AuthTokensResponse';
+export * from './dtos/AuthStartLoginRequest';
+export * from './dtos/AuthStartLoginResponse';
 export * from './dtos/InitiateAuthRequest';
 export * from './dtos/InitiateAuthResponse';
 export * from './dtos/VerifyPasswordRequest';

package/bin/cognitoBackofficeConnector/index.js

@@ -37,6 +37,8 @@ __exportStar(require("./dtos/UserDetailResponse"), exports);
 __exportStar(require("./dtos/AuthEventsRequest"), exports);
 __exportStar(require("./dtos/AuthEventResponse"), exports);
 __exportStar(require("./dtos/AuthTokensResponse"), exports);
+__exportStar(require("./dtos/AuthStartLoginRequest"), exports);
+__exportStar(require("./dtos/AuthStartLoginResponse"), exports);
 __exportStar(require("./dtos/InitiateAuthRequest"), exports);
 __exportStar(require("./dtos/InitiateAuthResponse"), exports);
 __exportStar(require("./dtos/VerifyPasswordRequest"), exports);

package/bin/platformRbac/auth/DefineNextChallengeRequest.d.ts

@@ -8,4 +8,5 @@ export declare class DefineNextChallengeRequest {
     cognitoSub: string;
     userNotFound: boolean;
     session: ChallengeResultEntry[];
+    userStatus?: string;
 }

package/bin/platformRbac/auth/DefineNextChallengeRequest.js

@@ -42,3 +42,8 @@ __decorate([
     (0, class_transformer_1.Type)(() => ChallengeResultEntry),
     __metadata("design:type", Array)
 ], DefineNextChallengeRequest.prototype, "session", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], DefineNextChallengeRequest.prototype, "userStatus", void 0);

package/bin/platformRbac/enums/ChallengeNameEnum.d.ts

@@ -4,5 +4,7 @@ export declare enum ChallengeNameEnum {
     TOTP = "TOTP",
     NEW_PASSWORD_REQUIRED = "NEW_PASSWORD_REQUIRED",
     RESET_PASSWORD = "RESET_PASSWORD",
-    SMS_OTP = "SMS_OTP"
+    SMS_OTP = "SMS_OTP",
+    SRP_A = "SRP_A",
+    PASSWORD_VERIFIER = "PASSWORD_VERIFIER"
 }

package/bin/platformRbac/enums/ChallengeNameEnum.js

@@ -9,4 +9,8 @@ var ChallengeNameEnum;
     ChallengeNameEnum["NEW_PASSWORD_REQUIRED"] = "NEW_PASSWORD_REQUIRED";
     ChallengeNameEnum["RESET_PASSWORD"] = "RESET_PASSWORD";
     ChallengeNameEnum["SMS_OTP"] = "SMS_OTP";
+    // SRP dentro de CUSTOM_AUTH: entries nativos que Cognito deja en session[] y que
+    // el orquestador del rbac lee para decidir el siguiente paso del login de un solo flujo.
+    ChallengeNameEnum["SRP_A"] = "SRP_A";
+    ChallengeNameEnum["PASSWORD_VERIFIER"] = "PASSWORD_VERIFIER";
 })(ChallengeNameEnum || (exports.ChallengeNameEnum = ChallengeNameEnum = {}));

package/bin/retailPromotions/constants/retailPromotionsErrorHttpStatus.js

@@ -34,4 +34,5 @@ exports.RETAIL_PROMOTIONS_ERROR_HTTP_STATUS = {
     [RetailPromotionsErrorCodeEnum_1.RetailPromotionsErrorCodeEnum.INVALID_NEXT_TOKEN]: 400,
     [RetailPromotionsErrorCodeEnum_1.RetailPromotionsErrorCodeEnum.CATALOG_SKU_NOT_FOUND]: 404,
     [RetailPromotionsErrorCodeEnum_1.RetailPromotionsErrorCodeEnum.SPLIT_FINANCING_DISABLED]: 409,
+    [RetailPromotionsErrorCodeEnum_1.RetailPromotionsErrorCodeEnum.PROMOTION_NOT_STACKABLE]: 422,
 };

package/bin/retailPromotions/dtos/LinePromotionAmount.d.ts

@@ -0,0 +1,6 @@
+/** Descuento que una promo le aplica a una línea; la suma de la lista + el código da el total. */
+export declare class LinePromotionAmount {
+    promotionId: string;
+    promotionVersion: number;
+    discountCents: number;
+}