@fiado/type-kit 3.615.0 → 3.617.0

package/src/reconciliation/dtos/requests/PrivateReconciliationRequests.ts

@@ -0,0 +1,166 @@
+import {
+    AddReconciliationItemNoteRequest,
+    ConfigureReconciliationDefinitionRequest,
+    ReactivateReconciliationItemRequest,
+    ResolveReconciliationItemRequest,
+    RunReconciliationRequest,
+} from './ReconciliationActionRequests';
+import {
+    GetReconciliationMatrixQuery,
+    GetReconciliationOverviewQuery,
+    GetReconciliationSummaryQuery,
+    ListReconciliationDefinitionsQuery,
+    ListReconciliationItemsQuery,
+    ListReconciliationRunsQuery,
+} from './ReconciliationQueries';
+import { RequiredEmail, RequiredId } from './reconciliationRequestDecorators';
+
+/** Tenant y servicio que llama; el lambda valida `author` contra su lista permitida. */
+export class PrivateReconciliationCaller {
+    @RequiredId()
+    tenantId!: string;
+
+    @RequiredId()
+    author!: string;
+}
+
+/** Caller del espejo que llama fiado-dashboard; `actor` es el email del operador de la sesión. */
+export class PrivateReconciliationOperatorCaller extends PrivateReconciliationCaller {
+    @RequiredEmail()
+    actor!: string;
+}
+
+/** Query de privateGetReconciliationItem. */
+export class PrivateGetReconciliationItemQuery extends PrivateReconciliationOperatorCaller {}
+
+/** Query de privateListReconciliationDefinitions. */
+export class PrivateListReconciliationDefinitionsQuery extends ListReconciliationDefinitionsQuery {
+    @RequiredId()
+    tenantId!: string;
+
+    @RequiredId()
+    author!: string;
+
+    @RequiredEmail()
+    actor!: string;
+}
+
+/** Body de privateConfigureReconciliationDefinition. */
+export class PrivateConfigureReconciliationDefinitionRequest extends ConfigureReconciliationDefinitionRequest {
+    @RequiredId()
+    tenantId!: string;
+
+    @RequiredId()
+    author!: string;
+
+    @RequiredEmail()
+    actor!: string;
+}
+
+/** Query de privateListReconciliationRuns. */
+export class PrivateListReconciliationRunsQuery extends ListReconciliationRunsQuery {
+    @RequiredId()
+    tenantId!: string;
+
+    @RequiredId()
+    author!: string;
+
+    @RequiredEmail()
+    actor!: string;
+}
+
+/** Body de privateRunReconciliation: responde 202 con `runId`. */
+export class PrivateRunReconciliationRequest extends RunReconciliationRequest {
+    @RequiredId()
+    tenantId!: string;
+
+    @RequiredId()
+    author!: string;
+
+    @RequiredEmail()
+    actor!: string;
+}
+
+/** Query de privateGetReconciliationMatrix. */
+export class PrivateGetReconciliationMatrixQuery extends GetReconciliationMatrixQuery {
+    @RequiredId()
+    tenantId!: string;
+
+    @RequiredId()
+    author!: string;
+
+    @RequiredEmail()
+    actor!: string;
+}
+
+/** Query de privateGetReconciliationOverview. */
+export class PrivateGetReconciliationOverviewQuery extends GetReconciliationOverviewQuery {
+    @RequiredId()
+    tenantId!: string;
+
+    @RequiredId()
+    author!: string;
+
+    @RequiredEmail()
+    actor!: string;
+}
+
+/** Query de privateGetReconciliationSummary. */
+export class PrivateGetReconciliationSummaryQuery extends GetReconciliationSummaryQuery {
+    @RequiredId()
+    tenantId!: string;
+
+    @RequiredId()
+    author!: string;
+
+    @RequiredEmail()
+    actor!: string;
+}
+
+/** Query de privateListReconciliationItems. */
+export class PrivateListReconciliationItemsQuery extends ListReconciliationItemsQuery {
+    @RequiredId()
+    tenantId!: string;
+
+    @RequiredId()
+    author!: string;
+
+    @RequiredEmail()
+    actor!: string;
+}
+
+/** Body de privateResolveReconciliationItem. */
+export class PrivateResolveReconciliationItemRequest extends ResolveReconciliationItemRequest {
+    @RequiredId()
+    tenantId!: string;
+
+    @RequiredId()
+    author!: string;
+
+    @RequiredEmail()
+    actor!: string;
+}
+
+/** Body de privateReactivateReconciliationItem. */
+export class PrivateReactivateReconciliationItemRequest extends ReactivateReconciliationItemRequest {
+    @RequiredId()
+    tenantId!: string;
+
+    @RequiredId()
+    author!: string;
+
+    @RequiredEmail()
+    actor!: string;
+}
+
+/** Body de privateAddReconciliationItemNote. */
+export class PrivateAddReconciliationItemNoteRequest extends AddReconciliationItemNoteRequest {
+    @RequiredId()
+    tenantId!: string;
+
+    @RequiredId()
+    author!: string;
+
+    @RequiredEmail()
+    actor!: string;
+}

package/src/reconciliation/dtos/requests/ReconciliationActionRequests.ts

@@ -0,0 +1,77 @@
+import { Expose } from 'class-transformer';
+import { ArrayUnique, IsArray, IsEnum, IsInt, IsISO8601, IsNotEmpty, IsOptional, IsString, Min } from 'class-validator';
+import { ReconciliationDefinitionStatusEnum } from '../../enums/ReconciliationDefinitionStatusEnum';
+import { ReconciliationResolutionTypeEnum } from '../../enums/ReconciliationResolutionTypeEnum';
+import { NoteText, PeriodKey, RequiredId, RequiredReason } from './reconciliationRequestDecorators';
+
+/** Body de publicConfigureReconciliationDefinition. */
+export class ConfigureReconciliationDefinitionRequest {
+    @Expose()
+    @IsEnum(ReconciliationDefinitionStatusEnum)
+    status!: ReconciliationDefinitionStatusEnum;
+
+    @Expose()
+    @IsOptional()
+    @IsInt()
+    @Min(0)
+    amountToleranceCents?: number;
+
+    @Expose()
+    @IsOptional()
+    @IsInt()
+    @Min(0)
+    waitBusinessDays?: number;
+
+    /** Reemplaza la lista completa de retailers de prueba. */
+    @Expose()
+    @IsOptional()
+    @IsArray()
+    @ArrayUnique()
+    @IsString({ each: true })
+    @IsNotEmpty({ each: true })
+    sandboxRetailerIds?: string[];
+
+    @Expose()
+    @IsOptional()
+    @IsArray()
+    @ArrayUnique()
+    @IsString({ each: true })
+    @IsNotEmpty({ each: true })
+    sandboxDirectoryIds?: string[];
+
+    @Expose()
+    @IsOptional()
+    @IsISO8601()
+    activeFrom?: string;
+}
+
+/** Body de publicRunReconciliation: responde 202 con `runId` y corre asíncrono. */
+export class RunReconciliationRequest {
+    @RequiredId()
+    definitionId!: string;
+
+    @PeriodKey()
+    periodKey!: string;
+}
+
+/** Body de publicResolveReconciliationItem; el monto del ajuste lo calcula el motor. */
+export class ResolveReconciliationItemRequest {
+    @Expose()
+    @IsEnum(ReconciliationResolutionTypeEnum)
+    type!: ReconciliationResolutionTypeEnum;
+
+    @RequiredReason()
+    reason!: string;
+}
+
+/** Body de publicReactivateReconciliationItem. */
+export class ReactivateReconciliationItemRequest {
+    @RequiredReason()
+    reason!: string;
+}
+
+/** Body de publicAddReconciliationItemNote; no cambia el estado. */
+export class AddReconciliationItemNoteRequest {
+    @NoteText()
+    text!: string;
+}

package/src/reconciliation/dtos/requests/ReconciliationFeedRequests.ts

@@ -0,0 +1,47 @@
+import { Expose } from 'class-transformer';
+import { IsEnum, IsISO8601 } from 'class-validator';
+import { ReconciliationFeedConceptEnum } from '../../enums/ReconciliationFeedConceptEnum';
+import { OptionalEmail, PageToken, RequiredId } from './reconciliationRequestDecorators';
+
+/** Path de privateListReconciliationFeed; cada dueño responde solo sus conceptos. */
+export class ReconciliationFeedPathParams {
+    @Expose()
+    @IsEnum(ReconciliationFeedConceptEnum)
+    concept!: ReconciliationFeedConceptEnum;
+}
+
+/** Path de privateGetReconciliationFeedRecord. */
+export class ReconciliationFeedRecordPathParams extends ReconciliationFeedPathParams {
+    @RequiredId()
+    recordId!: string;
+}
+
+/** Query de privateListReconciliationFeed: ventana ISO 8601 por `occurredAt`, páginas de 500. */
+export class PrivateListReconciliationFeedQuery {
+    @RequiredId()
+    tenantId!: string;
+
+    @Expose()
+    @IsISO8601()
+    from!: string;
+
+    @Expose()
+    @IsISO8601()
+    to!: string;
+
+    @PageToken()
+    cursor?: string;
+}
+
+/** Query de privateGetReconciliationFeedRecord; `author` y `actor` van al registro de acceso del dueño. */
+export class PrivateGetReconciliationFeedRecordQuery {
+    @RequiredId()
+    tenantId!: string;
+
+    @RequiredId()
+    author!: string;
+
+    /** Email del operador cuando la lectura sale del detalle de una partida. */
+    @OptionalEmail()
+    actor?: string;
+}

package/src/reconciliation/dtos/requests/ReconciliationQueries.ts

@@ -0,0 +1,148 @@
+import { Expose, Type } from 'class-transformer';
+import { IsEnum, IsInt, IsISO8601, IsOptional, IsString, Matches, Max, Min } from 'class-validator';
+import { TransferNotePartyTypeEnum } from '../../../transferNote/enums/TransferNotePartyTypeEnum';
+import { RECONCILIATION_MONTH_PATTERN } from '../../constants/reconciliationValidation';
+import { ReconciliationDefinitionStatusEnum } from '../../enums/ReconciliationDefinitionStatusEnum';
+import { ReconciliationExportFormatEnum } from '../../enums/ReconciliationExportFormatEnum';
+import { ReconciliationFeedConceptEnum } from '../../enums/ReconciliationFeedConceptEnum';
+import { ReconciliationItemStateEnum } from '../../enums/ReconciliationItemStateEnum';
+import { ReconciliationLayerEnum } from '../../enums/ReconciliationLayerEnum';
+import { ReconciliationRuleTypeEnum } from '../../enums/ReconciliationRuleTypeEnum';
+import { ReconciliationRunStatusEnum } from '../../enums/ReconciliationRunStatusEnum';
+import { PageLimit, PageToken, PeriodKey, RequiredId } from './reconciliationRequestDecorators';
+
+/** Query de publicListReconciliationDefinitions. */
+export class ListReconciliationDefinitionsQuery {
+    @Expose()
+    @IsOptional()
+    @IsString()
+    module?: string;
+
+    @Expose()
+    @IsOptional()
+    @IsEnum(ReconciliationRuleTypeEnum)
+    ruleType?: ReconciliationRuleTypeEnum;
+
+    @Expose()
+    @IsOptional()
+    @IsEnum(ReconciliationDefinitionStatusEnum)
+    status?: ReconciliationDefinitionStatusEnum;
+}
+
+/** Query de publicListReconciliationRuns. */
+export class ListReconciliationRunsQuery {
+    @RequiredId()
+    definitionId!: string;
+
+    @IsOptional()
+    @PeriodKey()
+    periodKey?: string;
+
+    @Expose()
+    @IsOptional()
+    @IsEnum(ReconciliationRunStatusEnum)
+    status?: ReconciliationRunStatusEnum;
+
+    @PageLimit()
+    limit?: number;
+
+    @PageToken()
+    nextToken?: string;
+}
+
+/** Query de publicGetReconciliationMatrix: conteos por mes del año. */
+export class GetReconciliationMatrixQuery {
+    @RequiredId()
+    definitionId!: string;
+
+    @Expose()
+    @Type(() => Number)
+    @IsInt()
+    @Min(2000)
+    @Max(2100)
+    year!: number;
+
+    @Expose()
+    @IsOptional()
+    @IsEnum(ReconciliationFeedConceptEnum)
+    concept?: ReconciliationFeedConceptEnum;
+
+    @Expose()
+    @IsOptional()
+    @IsString()
+    counterpartyId?: string;
+}
+
+/** Query de publicGetReconciliationOverview: resumen por contraparte de la pantalla 04. */
+export class GetReconciliationOverviewQuery {
+    @Expose()
+    @IsOptional()
+    @IsEnum(TransferNotePartyTypeEnum)
+    counterpartyType?: TransferNotePartyTypeEnum;
+}
+
+/** Query de publicGetReconciliationSummary: resumen por capa de un periodo. */
+export class GetReconciliationSummaryQuery {
+    @RequiredId()
+    definitionId!: string;
+
+    @PeriodKey()
+    periodKey!: string;
+
+    @Expose()
+    @IsOptional()
+    @IsEnum(ReconciliationLayerEnum)
+    layer?: ReconciliationLayerEnum;
+}
+
+/** Query de publicListReconciliationItems; `state=TEST` da la lista de sandbox. */
+export class ListReconciliationItemsQuery {
+    @RequiredId()
+    definitionId!: string;
+
+    @IsOptional()
+    @PeriodKey()
+    periodKey?: string;
+
+    @Expose()
+    @IsOptional()
+    @Matches(RECONCILIATION_MONTH_PATTERN)
+    month?: string;
+
+    /** Rango de `periodKey`, fechas ISO 8601. */
+    @Expose()
+    @IsOptional()
+    @IsISO8601()
+    from?: string;
+
+    @Expose()
+    @IsOptional()
+    @IsISO8601()
+    to?: string;
+
+    @Expose()
+    @IsOptional()
+    @IsEnum(ReconciliationItemStateEnum)
+    state?: ReconciliationItemStateEnum;
+
+    @Expose()
+    @IsOptional()
+    @IsEnum(ReconciliationFeedConceptEnum)
+    concept?: ReconciliationFeedConceptEnum;
+
+    @Expose()
+    @IsOptional()
+    @IsString()
+    counterpartyId?: string;
+
+    @Expose()
+    @IsOptional()
+    @IsEnum(ReconciliationExportFormatEnum)
+    format?: ReconciliationExportFormatEnum;
+
+    @PageLimit()
+    limit?: number;
+
+    @PageToken()
+    nextToken?: string;
+}

package/src/reconciliation/dtos/requests/reconciliationRequestDecorators.ts

@@ -0,0 +1,32 @@
+import { Expose, Transform } from 'class-transformer';
+import { IsEmail, IsOptional, IsString, Matches, MinLength } from 'class-validator';
+import { RECONCILIATION_MIN_NOTE_LENGTH, RECONCILIATION_PERIOD_KEY_PATTERN } from '../../constants/reconciliationValidation';
+
+export { PageLimit, PageToken, RequiredEmail, RequiredId, RequiredReason } from '../../../transferNote/dtos/requests/transferNoteRequestDecorators';
+
+/** Periodo obligatorio: día, semana ISO o mes. */
+export function PeriodKey(): PropertyDecorator {
+    return (target, key) => {
+        Expose()(target, key);
+        Matches(RECONCILIATION_PERIOD_KEY_PATTERN)(target, key);
+    };
+}
+
+/** Texto de 10+ caracteres sin contar espacios de relleno. */
+export function NoteText(): PropertyDecorator {
+    return (target, key) => {
+        Expose()(target, key);
+        Transform(({ value }) => (typeof value === 'string' ? value.trim() : value))(target, key);
+        IsString()(target, key);
+        MinLength(RECONCILIATION_MIN_NOTE_LENGTH)(target, key);
+    };
+}
+
+/** Email opcional. */
+export function OptionalEmail(): PropertyDecorator {
+    return (target, key) => {
+        Expose()(target, key);
+        IsOptional()(target, key);
+        IsEmail()(target, key);
+    };
+}

package/src/reconciliation/dtos/responses/PrivateReconciliationResponses.ts

@@ -0,0 +1,27 @@
+import {
+    AddReconciliationItemNoteResponse,
+    ConfigureReconciliationDefinitionResponse,
+    GetReconciliationItemResponse,
+    GetReconciliationMatrixResponse,
+    GetReconciliationOverviewResponse,
+    GetReconciliationSummaryResponse,
+    ListReconciliationDefinitionsResponse,
+    ListReconciliationItemsResponse,
+    ListReconciliationRunsResponse,
+    ReactivateReconciliationItemResponse,
+    ResolveReconciliationItemResponse,
+    RunReconciliationResponse,
+} from './ReconciliationResponses';
+
+export type PrivateListReconciliationDefinitionsResponse = ListReconciliationDefinitionsResponse;
+export type PrivateConfigureReconciliationDefinitionResponse = ConfigureReconciliationDefinitionResponse;
+export type PrivateListReconciliationRunsResponse = ListReconciliationRunsResponse;
+export type PrivateRunReconciliationResponse = RunReconciliationResponse;
+export type PrivateGetReconciliationMatrixResponse = GetReconciliationMatrixResponse;
+export type PrivateGetReconciliationOverviewResponse = GetReconciliationOverviewResponse;
+export type PrivateGetReconciliationSummaryResponse = GetReconciliationSummaryResponse;
+export type PrivateListReconciliationItemsResponse = ListReconciliationItemsResponse;
+export type PrivateGetReconciliationItemResponse = GetReconciliationItemResponse;
+export type PrivateResolveReconciliationItemResponse = ResolveReconciliationItemResponse;
+export type PrivateReactivateReconciliationItemResponse = ReactivateReconciliationItemResponse;
+export type PrivateAddReconciliationItemNoteResponse = AddReconciliationItemNoteResponse;

package/src/reconciliation/dtos/responses/ReconciliationFeedResponses.ts

@@ -0,0 +1,9 @@
+import { ReconciliationFeedRecord } from '../ReconciliationFeedRecord';
+
+/** Página de un feed; sin `cursor` no hay más. Notas lo usa con sus propios registros. */
+export interface PrivateListReconciliationFeedResponse<TRecord = ReconciliationFeedRecord> {
+    records: TRecord[];
+    cursor?: string;
+}
+
+export type PrivateGetReconciliationFeedRecordResponse<TRecord = ReconciliationFeedRecord> = TRecord;

package/src/reconciliation/dtos/responses/ReconciliationResponses.ts

@@ -0,0 +1,101 @@
+import { TransferNotePartyTypeEnum } from '../../../transferNote/enums/TransferNotePartyTypeEnum';
+import { ReconciliationLayerEnum } from '../../enums/ReconciliationLayerEnum';
+import { ReconciliationRuleTypeEnum } from '../../enums/ReconciliationRuleTypeEnum';
+import { ReconciliationDefinition } from '../ReconciliationDefinition';
+import {
+    ReconciliationItem,
+    ReconciliationItemLiveDetail,
+    ReconciliationItemNote,
+    ReconciliationResolutionHistoryEntry,
+} from '../ReconciliationItem';
+import { ReconciliationRun, ReconciliationStateCount } from '../ReconciliationRun';
+
+export interface ListReconciliationDefinitionsResponse {
+    items: ReconciliationDefinition[];
+}
+
+export type ConfigureReconciliationDefinitionResponse = ReconciliationDefinition;
+
+export interface ListReconciliationRunsResponse {
+    items: ReconciliationRun[];
+    nextToken?: string;
+}
+
+/** Respuesta 202 de la corrida manual. */
+export interface RunReconciliationResponse {
+    runId: string;
+}
+
+/** Conteos de una celda; las resueltas a mano y las ajustadas cuentan en OK con su marca. */
+export interface ReconciliationMatrixCounts {
+    counts: ReconciliationStateCount[];
+    manuallyResolvedCount: number;
+    adjustedCount: number;
+}
+
+export interface ReconciliationMatrixRow extends ReconciliationMatrixCounts {
+    /** Mes `YYYY-MM`. */
+    month: string;
+}
+
+/** Matriz anual; TEST no cuenta. */
+export interface GetReconciliationMatrixResponse {
+    definitionId: string;
+    ruleType: ReconciliationRuleTypeEnum;
+    year: number;
+    expectedSideName?: string;
+    executedSideName?: string;
+    rows: ReconciliationMatrixRow[];
+    total: ReconciliationMatrixCounts;
+    lastRunAt?: string;
+    nextRunAt?: string;
+}
+
+export interface ReconciliationCounterpartyOverview {
+    counterpartyType: TransferNotePartyTypeEnum;
+    counterpartyId: string;
+    okCount: number;
+    differenceCount: number;
+    lastRunAt?: string;
+}
+
+/** Salud de la conciliación por contraparte, no la mora. */
+export interface GetReconciliationOverviewResponse {
+    items: ReconciliationCounterpartyOverview[];
+}
+
+export interface ReconciliationLayerSummary {
+    layer: ReconciliationLayerEnum;
+    counts: ReconciliationStateCount[];
+    expectedAmountCents?: number;
+    executedAmountCents?: number;
+    differenceCents?: number;
+}
+
+export interface GetReconciliationSummaryResponse {
+    definitionId: string;
+    periodKey: string;
+    layers: ReconciliationLayerSummary[];
+}
+
+/** Con `format=csv` el cuerpo es `text/csv` con las mismas columnas. */
+export interface ListReconciliationItemsResponse {
+    items: ReconciliationItem[];
+    total: number;
+    nextToken?: string;
+}
+
+/** Partida con sus notas, su historial y el detalle en vivo. */
+export interface GetReconciliationItemResponse extends ReconciliationItem {
+    notes: ReconciliationItemNote[];
+    resolutionHistory: ReconciliationResolutionHistoryEntry[];
+    liveDetail: ReconciliationItemLiveDetail;
+}
+
+/** El mismo ajuste repetido devuelve la primera resolución. */
+export type ResolveReconciliationItemResponse = ReconciliationItem;
+export type ReactivateReconciliationItemResponse = ReconciliationItem;
+
+export interface AddReconciliationItemNoteResponse {
+    notes: ReconciliationItemNote[];
+}

package/src/reconciliation/enums/ReconciliationDefinitionStatusEnum.ts

@@ -0,0 +1,6 @@
+/** En SHADOW la definición corre y guarda partidas, pero las lecturas públicas responden vacío. */
+export enum ReconciliationDefinitionStatusEnum {
+    PAUSED = 'PAUSED',
+    SHADOW = 'SHADOW',
+    ACTIVE = 'ACTIVE',
+}

package/src/reconciliation/enums/ReconciliationErrorCodeEnum.ts

@@ -0,0 +1,24 @@
+/**
+ * Codes de error de reconciliation-engine-business; el status de cada uno está en
+ * `RECONCILIATION_ERROR_HTTP_STATUS`. Las clases `DomainError` viven en el lambda.
+ */
+export enum ReconciliationErrorCodeEnum {
+    DEFINITION_NOT_FOUND = 'DEFINITION_NOT_FOUND',
+    RUN_IN_PROGRESS = 'RUN_IN_PROGRESS',
+    ITEM_NOT_FOUND = 'ITEM_NOT_FOUND',
+    /** La partida ya tiene otra resolución; el mismo ajuste repetido responde 200 con el primero. */
+    ITEM_ALREADY_RESOLVED = 'ITEM_ALREADY_RESOLVED',
+    ADJUSTMENT_IN_PROGRESS = 'ADJUSTMENT_IN_PROGRESS',
+    /** Faltó lo ejecutado o fue de menos: se corrige en el origen y la partida sigue abierta. */
+    ADJUSTMENT_UNDER_EXECUTED = 'ADJUSTMENT_UNDER_EXECUTED',
+    /** La partida está en OK. */
+    ADJUSTMENT_NOT_ALLOWED = 'ADJUSTMENT_NOT_ALLOWED',
+    /** El dueño del dinero rechazó el ajuste. */
+    ADJUSTMENT_REJECTED = 'ADJUSTMENT_REJECTED',
+    /** El dueño del dinero no respondió. */
+    ADJUSTMENT_UNAVAILABLE = 'ADJUSTMENT_UNAVAILABLE',
+    /** Una partida ajustada no se reactiva. */
+    ITEM_ADJUSTED = 'ITEM_ADJUSTED',
+    /** El `author` del espejo privado no está en la lista permitida del lambda. */
+    AUTHOR_NOT_ALLOWED = 'AUTHOR_NOT_ALLOWED',
+}

package/src/reconciliation/enums/ReconciliationExportFormatEnum.ts

@@ -0,0 +1,5 @@
+/** Formato de `GET /reconciliation/items`. */
+export enum ReconciliationExportFormatEnum {
+    JSON = 'json',
+    CSV = 'csv',
+}

package/src/reconciliation/enums/ReconciliationFeedConceptEnum.ts

@@ -0,0 +1,19 @@
+import { TransferNoteConceptEnum } from '../../transferNote/enums/TransferNoteConceptEnum';
+import { TransferNoteFeedConceptEnum } from '../../transferNote/enums/TransferNoteFeedConceptEnum';
+
+/** Conceptos de `GET /private/reconciliation-feeds/{concept}`; reusa los strings de transferNote. */
+export enum ReconciliationFeedConceptEnum {
+    INSTALLMENT_COLLECTION = TransferNoteConceptEnum.INSTALLMENT_COLLECTION,
+    CREDIT_PROMOTION_REIMBURSEMENT = TransferNoteConceptEnum.CREDIT_PROMOTION_REIMBURSEMENT,
+    SALE_PROMOTION_REIMBURSEMENT = TransferNoteConceptEnum.SALE_PROMOTION_REIMBURSEMENT,
+    /** Apagado hasta que exista el pago a la wallet del vendedor. */
+    SALE_COMMISSION = TransferNoteConceptEnum.SALE_COMMISSION,
+    DEVICE_PAYMENT = TransferNoteConceptEnum.DEVICE_PAYMENT,
+    DOWN_PAYMENT = TransferNoteConceptEnum.DOWN_PAYMENT,
+    /** Un registro por crédito con contrato firmado, incluidos los cancelados dentro de 7 días. */
+    SIGNED_CREDIT = 'SIGNED_CREDIT',
+    /** Movimientos de las cuentas del gateway. */
+    GATEWAY_LEDGER = 'GATEWAY_LEDGER',
+    TRANSFER_NOTE_ITEM = TransferNoteFeedConceptEnum.TRANSFER_NOTE_ITEM,
+    TRANSFER_NOTE_SETTLEMENT = TransferNoteFeedConceptEnum.TRANSFER_NOTE_SETTLEMENT,
+}

package/src/reconciliation/enums/ReconciliationFeedErrorCodeEnum.ts

@@ -0,0 +1,4 @@
+/** Codes del feed genérico que implementa cada dueño del dato. */
+export enum ReconciliationFeedErrorCodeEnum {
+    FEED_RECORD_NOT_FOUND = 'FEED_RECORD_NOT_FOUND',
+}

package/src/reconciliation/enums/ReconciliationFeedOwnerEnum.ts

@@ -0,0 +1,9 @@
+/** Lambda dueño de un feed; el valor es el nombre del lambda al que llama el motor. */
+export enum ReconciliationFeedOwnerEnum {
+    LOAN_CREDIT_BUSINESS = 'loan-credit-business',
+    LOAN_OFFERINGS_BUSINESS = 'loan-offerings-business',
+    RETAIL_CUSTOMER_BUSINESS = 'retail-customer-business',
+    RETAIL_WIZARD_BUSINESS = 'retail-wizard-business',
+    TRANSACTION_BUSINESS = 'transaction-business',
+    TRANSFER_NOTE_BUSINESS = 'transfer-note-business',
+}