@ketvietlab/ketsuite 0.1.2 → 0.1.5

package/dist/modules/pos_channel/operations.js

@@ -0,0 +1,1781 @@
+import { channelCommandId, channelError, defineChannelRoute, routesOf, } from '../channel_api/core.js';
+const string = { type: 'string' };
+const integer = { type: 'integer', minimum: 0 };
+const nullableString = { type: ['string', 'null'] };
+const object = { type: 'object' };
+const boolean = { type: 'boolean' };
+const n = (value) => Number(value ?? 0);
+const invalid = (field, message) => ({ ok: false, errors: [{ field, message }] });
+const envelope = (data) => ({
+    type: 'object',
+    properties: { data, error: {}, meta: { type: 'object' } },
+});
+const idParams = {
+    type: 'object',
+    additionalProperties: false,
+    properties: { id: string },
+    required: ['id'],
+};
+const lineParams = {
+    type: 'object',
+    additionalProperties: false,
+    properties: { id: string, lineId: string },
+    required: ['id', 'lineId'],
+};
+const tenderParams = {
+    type: 'object',
+    additionalProperties: false,
+    properties: { id: string, tenderId: string },
+    required: ['id', 'tenderId'],
+};
+const movementParams = {
+    type: 'object',
+    additionalProperties: false,
+    properties: { id: string, movementId: string },
+    required: ['id', 'movementId'],
+};
+const expectedBody = {
+    type: 'object',
+    additionalProperties: false,
+    properties: { expectedRevision: integer },
+    required: ['expectedRevision'],
+};
+const lotSelection = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        lotId: string,
+        quantity: string,
+        stockRevision: nullableString,
+    },
+    required: ['lotId', 'quantity', 'stockRevision'],
+};
+const orderLine = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        id: string,
+        productId: string,
+        uomId: string,
+        name: string,
+        quantity: string,
+        unitPrice: string,
+        discount: string,
+        taxIds: { type: 'array', items: string },
+        amountUntaxed: string,
+        amountTotal: string,
+        sequence: integer,
+        quoteRevision: nullableString,
+        tracking: string,
+        lotSelections: { type: 'array', items: lotSelection },
+        originalLineId: nullableString,
+    },
+    required: [
+        'id',
+        'productId',
+        'uomId',
+        'name',
+        'quantity',
+        'unitPrice',
+        'discount',
+        'taxIds',
+        'amountUntaxed',
+        'amountTotal',
+        'sequence',
+        'quoteRevision',
+        'tracking',
+        'lotSelections',
+        'originalLineId',
+    ],
+};
+const returnEligibilityLine = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        lineId: string,
+        productId: string,
+        name: string,
+        uomId: string,
+        purchasedQuantity: string,
+        refundedQuantity: string,
+        remainingQuantity: string,
+        unitPrice: string,
+        amountTotal: string,
+        tracking: string,
+    },
+    required: [
+        'lineId',
+        'productId',
+        'name',
+        'uomId',
+        'purchasedQuantity',
+        'refundedQuantity',
+        'remainingQuantity',
+        'unitPrice',
+        'amountTotal',
+        'tracking',
+    ],
+};
+const returnEligibility = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        originalOrderId: string,
+        revision: integer,
+        refundable: boolean,
+        requiresFullReturn: boolean,
+        standaloneAllowed: boolean,
+        lines: { type: 'array', items: returnEligibilityLine },
+    },
+    required: ['originalOrderId', 'revision', 'refundable', 'requiresFullReturn', 'standaloneAllowed', 'lines'],
+};
+const lotAvailability = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        orderId: string,
+        lineId: string,
+        productId: string,
+        tracking: string,
+        requiredQuantity: string,
+        selections: { type: 'array', items: lotSelection },
+        lots: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    lotId: string,
+                    name: string,
+                    expirationDate: nullableString,
+                    availableQuantity: string,
+                    stockRevision: string,
+                    selectable: { type: 'boolean' },
+                },
+                required: ['lotId', 'name', 'expirationDate', 'availableQuantity', 'stockRevision', 'selectable'],
+            },
+        },
+    },
+    required: ['orderId', 'lineId', 'productId', 'tracking', 'requiredQuantity', 'selections', 'lots'],
+};
+const tender = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        id: string,
+        paymentMethodId: string,
+        state: string,
+        kind: string,
+        tenderedAmount: string,
+        appliedAmount: string,
+        change: string,
+        reference: nullableString,
+        paymentDate: string,
+    },
+    required: [
+        'id',
+        'paymentMethodId',
+        'state',
+        'kind',
+        'tenderedAmount',
+        'appliedAmount',
+        'change',
+        'reference',
+        'paymentDate',
+    ],
+};
+const exchangeLink = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        id: string,
+        uuid: string,
+        role: { type: 'string', enum: ['return', 'replacement'] },
+        originalOrderId: string,
+        returnOrderId: string,
+        replacementOrderId: string,
+        originalRevision: integer,
+        reason: string,
+        createdAt: string,
+    },
+    required: [
+        'id',
+        'uuid',
+        'role',
+        'originalOrderId',
+        'returnOrderId',
+        'replacementOrderId',
+        'originalRevision',
+        'reason',
+        'createdAt',
+    ],
+};
+const nullableExchangeLink = { ...exchangeLink, type: ['object', 'null'] };
+const receiptTax = {
+    type: 'object',
+    additionalProperties: false,
+    properties: { id: string, name: string, amount: string },
+    required: ['id', 'name', 'amount'],
+};
+const receiptLine = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        id: string,
+        productId: string,
+        uomId: string,
+        name: string,
+        quantity: string,
+        unitPrice: string,
+        discount: string,
+        amountUntaxed: string,
+        amountTax: string,
+        amountTotal: string,
+        taxes: { type: 'array', items: receiptTax },
+    },
+    required: [
+        'id',
+        'productId',
+        'uomId',
+        'name',
+        'quantity',
+        'unitPrice',
+        'discount',
+        'amountUntaxed',
+        'amountTax',
+        'amountTotal',
+        'taxes',
+    ],
+};
+const receiptTender = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        paymentMethodId: string,
+        paymentMethodName: string,
+        tenderedAmount: string,
+        appliedAmount: string,
+        change: string,
+        paidAt: string,
+    },
+    required: ['paymentMethodId', 'paymentMethodName', 'tenderedAmount', 'appliedAmount', 'change', 'paidAt'],
+};
+const receiptDocument = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        schema: { type: 'string', enum: ['ketviet.pos.receipt.v1'] },
+        company: {
+            type: 'object',
+            additionalProperties: false,
+            properties: { id: string },
+            required: ['id'],
+        },
+        config: {
+            type: 'object',
+            additionalProperties: false,
+            properties: { id: string, name: string },
+            required: ['id', 'name'],
+        },
+        shift: {
+            type: 'object',
+            additionalProperties: false,
+            properties: { id: string, name: string },
+            required: ['id', 'name'],
+        },
+        cashier: {
+            type: 'object',
+            additionalProperties: false,
+            properties: { id: string },
+            required: ['id'],
+        },
+        customer: {
+            type: 'object',
+            additionalProperties: false,
+            properties: { id: string, name: string },
+            required: ['id', 'name'],
+        },
+        order: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                id: string,
+                name: string,
+                reference: string,
+                orderedAt: string,
+                isReturn: boolean,
+                originalOrderId: nullableString,
+            },
+            required: ['id', 'name', 'reference', 'orderedAt', 'isReturn', 'originalOrderId'],
+        },
+        currency: string,
+        lines: { type: 'array', items: receiptLine },
+        tenders: { type: 'array', items: receiptTender },
+        totals: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                untaxed: string,
+                tax: string,
+                exact: string,
+                rounding: string,
+                total: string,
+                paid: string,
+                change: string,
+            },
+            required: ['untaxed', 'tax', 'exact', 'rounding', 'total', 'paid', 'change'],
+        },
+        invoice: {
+            type: 'object',
+            additionalProperties: false,
+            properties: { id: string },
+            required: ['id'],
+        },
+        issuedAt: string,
+    },
+    required: [
+        'schema',
+        'company',
+        'config',
+        'shift',
+        'cashier',
+        'customer',
+        'order',
+        'currency',
+        'lines',
+        'tenders',
+        'totals',
+        'invoice',
+        'issuedAt',
+    ],
+};
+const receipt = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        id: string,
+        orderId: string,
+        version: integer,
+        templateVersion: string,
+        contentHash: string,
+        issuedAt: string,
+        document: receiptDocument,
+    },
+    required: ['id', 'orderId', 'version', 'templateVersion', 'contentHash', 'issuedAt', 'document'],
+};
+const order = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        id: string,
+        name: string,
+        uuid: string,
+        reference: string,
+        state: string,
+        shiftId: string,
+        customerId: nullableString,
+        note: nullableString,
+        currency: string,
+        amountUntaxed: string,
+        amountTax: string,
+        amountExact: string,
+        amountRounding: string,
+        amountTotal: string,
+        amountPaid: string,
+        amountReturn: string,
+        priceBookRevision: nullableString,
+        isReturn: boolean,
+        originalOrderId: nullableString,
+        returnPortion: nullableString,
+        returnComplete: boolean,
+        accountMoveId: nullableString,
+        pickingId: nullableString,
+        receiptId: nullableString,
+        exchange: nullableExchangeLink,
+        revision: integer,
+        lines: { type: 'array', items: orderLine },
+        tenders: { type: 'array', items: tender },
+        allowedActions: { type: 'array', items: string },
+    },
+    required: [
+        'id',
+        'name',
+        'uuid',
+        'reference',
+        'state',
+        'shiftId',
+        'customerId',
+        'note',
+        'currency',
+        'amountUntaxed',
+        'amountTax',
+        'amountExact',
+        'amountRounding',
+        'amountTotal',
+        'amountPaid',
+        'amountReturn',
+        'priceBookRevision',
+        'isReturn',
+        'originalOrderId',
+        'returnPortion',
+        'returnComplete',
+        'accountMoveId',
+        'pickingId',
+        'receiptId',
+        'exchange',
+        'revision',
+        'lines',
+        'tenders',
+        'allowedActions',
+    ],
+};
+const exchangeDraft = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        id: string,
+        uuid: string,
+        originalOrderId: string,
+        returnOrderId: string,
+        replacementOrderId: string,
+        originalRevision: integer,
+        reason: string,
+        createdAt: string,
+        returnOrder: order,
+        replacementOrder: order,
+    },
+    required: [
+        'id',
+        'uuid',
+        'originalOrderId',
+        'returnOrderId',
+        'replacementOrderId',
+        'originalRevision',
+        'reason',
+        'createdAt',
+        'returnOrder',
+        'replacementOrder',
+    ],
+};
+const shift = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        id: string,
+        name: string,
+        state: string,
+        operatorId: string,
+        deviceId: nullableString,
+        openedAt: nullableString,
+        closedAt: nullableString,
+        openingCash: string,
+        expectedCash: string,
+        countedCash: string,
+        difference: string,
+        cashMovementTotal: string,
+        varianceStatus: string,
+        varianceReason: nullableString,
+        varianceNote: nullableString,
+        varianceApprovedBy: nullableString,
+        cashAdjustmentId: nullableString,
+        revision: integer,
+        orderCount: integer,
+    },
+    required: [
+        'id',
+        'name',
+        'state',
+        'operatorId',
+        'deviceId',
+        'openedAt',
+        'closedAt',
+        'openingCash',
+        'expectedCash',
+        'countedCash',
+        'difference',
+        'cashMovementTotal',
+        'varianceStatus',
+        'varianceReason',
+        'varianceNote',
+        'varianceApprovedBy',
+        'cashAdjustmentId',
+        'revision',
+        'orderCount',
+    ],
+};
+const failure = (ctx, url, req, result) => {
+    const issues = Array.isArray(result?.errors)
+        ? (result.errors ?? [])
+        : [];
+    const conflict = issues.some((issue) => ['expectedRevision', 'state', 'quoteRevision', 'priceBookRevision'].includes(String(issue.field)));
+    return {
+        status: conflict ? 409 : 422,
+        error: channelError(ctx, url, req, conflict ? 'pos.commandConflict' : 'pos.commandInvalid', {
+            messageKey: conflict ? 'pos_channel.error.commandConflict' : 'pos_channel.error.commandInvalid',
+            fieldErrors: Object.fromEntries(issues.map((issue) => [
+                String(issue.field ?? 'command'),
+                {
+                    code: 'pos.invalidField',
+                    messageKey: 'pos_channel.error.invalidField',
+                    params: {},
+                },
+            ])),
+            retryable: conflict,
+        }),
+    };
+};
+const notFound = (ctx, url, req) => ({
+    status: 404,
+    error: channelError(ctx, url, req, 'pos.notFound', {
+        messageKey: 'pos_channel.error.notFound',
+    }),
+});
+const keyOf = (ctx, url, req) => {
+    const key = String(req.headers['idempotency-key'] ?? '').trim();
+    if (key.length >= 8 && key.length <= 200)
+        return key;
+    return {
+        status: 400,
+        error: channelError(ctx, url, req, 'channel_api.idempotencyRequired', {
+            messageKey: 'channel_api.error.idempotencyRequired',
+        }),
+    };
+};
+const projectOrder = (row) => ({
+    id: String(row.id),
+    name: String(row.name),
+    uuid: String(row.uuid),
+    reference: String(row.posReference),
+    state: String(row.state),
+    shiftId: String(row.sessionId),
+    customerId: row.partnerId == null ? null : String(row.partnerId),
+    note: row.note == null ? null : String(row.note),
+    currency: String(row.currency),
+    amountUntaxed: String(row.amountUntaxed),
+    amountTax: String(row.amountTax),
+    amountExact: String(row.amountExact ?? row.amountTotal),
+    amountRounding: String(row.amountRounding ?? 0),
+    amountTotal: String(row.amountTotal),
+    amountPaid: String(row.amountPaid),
+    amountReturn: String(row.amountReturn),
+    priceBookRevision: row.priceBookRevision == null ? null : String(row.priceBookRevision),
+    isReturn: Boolean(row.isRefund),
+    originalOrderId: row.refundedOrderId == null ? null : String(row.refundedOrderId),
+    returnPortion: row.returnPortion == null ? null : String(row.returnPortion),
+    returnComplete: Boolean(row.returnComplete),
+    accountMoveId: row.accountMoveId == null ? null : String(row.accountMoveId),
+    pickingId: row.pickingId == null ? null : String(row.pickingId),
+    receiptId: row.receiptId == null ? null : String(row.receiptId),
+    exchange: row.exchange && typeof row.exchange === 'object'
+        ? {
+            id: String(row.exchange.id),
+            uuid: String(row.exchange.uuid),
+            role: String(row.exchangeRole),
+            originalOrderId: String(row.exchange.originalOrderId),
+            returnOrderId: String(row.exchange.returnOrderId),
+            replacementOrderId: String(row.exchange.replacementOrderId),
+            originalRevision: Number(row.exchange.originalRevision),
+            reason: String(row.exchange.reason),
+            createdAt: String(row.exchange.createdAt),
+        }
+        : null,
+    revision: Number(row.revision ?? 0),
+    lines: (Array.isArray(row.lines) ? row.lines : [])
+        .map((line) => ({
+        id: String(line.id),
+        productId: String(line.productId),
+        uomId: String(line.productUomId),
+        name: String(line.name),
+        quantity: String(line.qty),
+        unitPrice: String(line.priceUnit),
+        discount: String(line.discount),
+        taxIds: Array.isArray(line.taxIds) ? line.taxIds.map(String) : line.taxId ? [String(line.taxId)] : [],
+        amountUntaxed: String(line.priceSubtotal),
+        amountTotal: String(line.priceSubtotalIncl),
+        sequence: Number(line.sequence),
+        quoteRevision: line.quoteRevision == null ? null : String(line.quoteRevision),
+        tracking: String(line.tracking ?? 'none'),
+        lotSelections: (Array.isArray(line.lotSelections) ? line.lotSelections : []).map((selection) => ({
+            lotId: String(selection.lotId),
+            quantity: String(selection.quantity),
+            stockRevision: selection.stockRevision == null ? null : String(selection.stockRevision),
+        })),
+        originalLineId: line.refundedOrderlineId == null ? null : String(line.refundedOrderlineId),
+    }))
+        .sort((left, right) => left.sequence - right.sequence || left.id.localeCompare(right.id)),
+    tenders: (Array.isArray(row.payments) ? row.payments : []).map((payment) => ({
+        id: String(payment.id),
+        paymentMethodId: String(payment.paymentMethodId),
+        state: String(payment.state ?? 'captured'),
+        kind: String(payment.kind ?? 'manual'),
+        tenderedAmount: String(payment.tenderedAmount ?? payment.amount),
+        appliedAmount: String(payment.appliedAmount ?? payment.amount),
+        change: String(n(payment.tenderedAmount ?? payment.amount) - n(payment.appliedAmount ?? payment.amount)),
+        reference: payment.reference == null ? null : String(payment.reference),
+        paymentDate: String(payment.paymentDate),
+    })),
+    allowedActions: row.state === 'draft' && row.isRefund
+        ? ['add_tender', 'void_tender', 'finalize', 'cancel']
+        : row.state === 'draft'
+            ? [
+                'update',
+                'add_line',
+                'update_line',
+                'remove_line',
+                'reorder_lines',
+                'add_tender',
+                'void_tender',
+                'finalize',
+                'cancel',
+            ]
+            : ['paid', 'done'].includes(String(row.state))
+                ? [...(!row.isRefund ? ['create_return', 'create_exchange'] : []), 'read_receipt']
+                : [],
+});
+const projectReceipt = (row) => ({
+    id: String(row.id),
+    orderId: String(row.orderId),
+    version: Number(row.version),
+    templateVersion: String(row.templateVersion),
+    contentHash: String(row.contentHash),
+    issuedAt: String(row.issuedAt),
+    document: row.document,
+});
+const orderFor = async (ctx, url, req, id, identity) => {
+    const row = (await ctx.call('pos.getOrder', { id }, url, req));
+    if (!row || String(row.configId) !== String(identity.posConfigId))
+        return null;
+    if (row.state === 'draft' && row.deviceId && String(row.deviceId) !== String(identity.deviceId))
+        return null;
+    return row;
+};
+const orderResult = async (ctx, url, req, id, identity) => {
+    const row = await orderFor(ctx, url, req, id, identity);
+    if (!row)
+        return notFound(ctx, url, req);
+    const data = projectOrder(row);
+    return { data, headers: { etag: `"pos-order-${data.revision}"` } };
+};
+const projectShift = (row) => ({
+    id: String(row.id),
+    name: String(row.name),
+    state: String(row.state),
+    operatorId: String(row.userId),
+    deviceId: row.deviceId == null ? null : String(row.deviceId),
+    openedAt: row.startAt == null ? null : String(row.startAt),
+    closedAt: row.stopAt == null ? null : String(row.stopAt),
+    openingCash: String(row.cashRegisterBalanceStart),
+    expectedCash: String(row.cashRegisterBalanceEnd),
+    countedCash: String(row.cashRegisterBalanceEndReal),
+    difference: String(row.cashRegisterDifference),
+    cashMovementTotal: String((Array.isArray(row.cashMovements) ? row.cashMovements : []).reduce((sum, movement) => sum + (movement.direction === 'in' ? n(movement.amount) : -n(movement.amount)), 0)),
+    varianceStatus: String(row.varianceStatus ?? 'none'),
+    varianceReason: row.varianceReason == null ? null : String(row.varianceReason),
+    varianceNote: row.varianceNote == null ? null : String(row.varianceNote),
+    varianceApprovedBy: row.varianceApprovedBy == null ? null : String(row.varianceApprovedBy),
+    cashAdjustmentId: row.cashAdjustmentId == null ? null : String(row.cashAdjustmentId),
+    revision: Number(row.revision ?? 0),
+    orderCount: Array.isArray(row.orders) ? row.orders.length : 0,
+});
+const shiftFor = async (ctx, url, req, id, identity) => {
+    const row = (await ctx.call('pos.getSession', { id }, url, req));
+    if (!row || String(row.configId) !== String(identity.posConfigId))
+        return null;
+    if (row.deviceId && String(row.deviceId) !== String(identity.deviceId))
+        return null;
+    return row;
+};
+const managerShiftFor = async (ctx, url, req, id, identity) => {
+    const row = (await ctx.call('pos.getSession', { id }, url, req));
+    return row && String(row.configId) === String(identity.posConfigId) ? row : null;
+};
+const shiftResult = async (ctx, url, req, id, identity) => {
+    const row = await shiftFor(ctx, url, req, id, identity);
+    if (!row)
+        return notFound(ctx, url, req);
+    const data = projectShift(row);
+    return { data, headers: { etag: `"pos-shift-${data.revision}"` } };
+};
+const commandOptions = (identity, action, key) => ({
+    idempotencyKey: key,
+    idempotencyNamespace: `pos:${identity.companyId}:${identity.posConfigId}:${identity.deviceId}:${action}`,
+    correlationId: key,
+});
+const lifecycleFunction = async (ctx, req, preferred, fallback) => (await ctx.live(req)).functions[preferred] ? preferred : fallback;
+export const operationRoutes = routesOf(defineChannelRoute({
+    profile: 'pos',
+    method: 'POST',
+    path: 'shifts',
+    operationId: 'pos.shifts.create',
+    summary: 'Create one opening-control shift in the live device configuration.',
+    auth: 'required',
+    request: {
+        body: {
+            type: 'object',
+            additionalProperties: false,
+            properties: { openingCash: string, openingNotes: string },
+            required: ['openingCash'],
+        },
+    },
+    responses: {
+        '200': envelope(shift),
+        '400': envelope(object),
+        '409': envelope(object),
+        '422': envelope(object),
+    },
+    idempotent: true,
+    handler: async (ctx, url, req, _params, request) => {
+        const key = keyOf(ctx, url, req);
+        if (typeof key !== 'string')
+            return key;
+        const identity = request.identity;
+        const id = channelCommandId('shift', identity, key);
+        const result = (await ctx.call('pos.createSession', {
+            id,
+            configId: identity.posConfigId,
+            userId: identity.operatorId,
+            deviceId: identity.deviceId,
+            openingCash: request.body.openingCash,
+            openingNotes: request.body.openingNotes,
+        }, url, req, commandOptions(identity, 'shift.create', key)));
+        if (result.ok !== true)
+            return failure(ctx, url, req, result);
+        return shiftResult(ctx, url, req, id, identity);
+    },
+}), defineChannelRoute({
+    profile: 'pos',
+    method: 'GET',
+    path: 'shifts/current',
+    operationId: 'pos.shifts.current',
+    summary: 'Read the active shift for the live device configuration, or null when none is open.',
+    auth: 'required',
+    responses: { '200': envelope({ anyOf: [shift, { type: 'null' }] }) },
+    handler: async (ctx, url, req, _params, request) => {
+        const identity = request.identity;
+        const sessions = (await ctx.call('pos.listSessions', {}, url, req));
+        const active = sessions
+            .filter((row) => String(row.configId) === String(identity.posConfigId) &&
+            (!row.deviceId || String(row.deviceId) === String(identity.deviceId)) &&
+            ['opening_control', 'opened', 'closing_control'].includes(String(row.state)))
+            .sort((left, right) => String(right.startAt ?? '').localeCompare(String(left.startAt ?? '')))[0];
+        if (!active)
+            return { data: null };
+        const row = (await ctx.call('pos.getSession', { id: active.id }, url, req));
+        return { data: projectShift(row), headers: { etag: `"pos-shift-${Number(row.revision ?? 0)}"` } };
+    },
+}), defineChannelRoute({
+    profile: 'pos',
+    method: 'GET',
+    path: 'shifts/{id}',
+    operationId: 'pos.shifts.get',
+    summary: 'Read one canonical revisioned shift.',
+    auth: 'required',
+    request: { params: idParams },
+    responses: { '200': envelope(shift), '404': envelope(object) },
+    handler: (ctx, url, req, params, request) => shiftResult(ctx, url, req, params.id, request.identity),
+}), ...['open', 'start-closing'].map((action) => defineChannelRoute({
+    profile: 'pos',
+    method: 'POST',
+    path: `shifts/{id}/${action}`,
+    operationId: `pos.shifts.${action === 'open' ? 'open' : 'startClosing'}`,
+    summary: action === 'open' ? 'Open an opening-control shift.' : 'Move an open shift to closing control.',
+    auth: 'required',
+    request: { params: idParams, body: expectedBody },
+    responses: {
+        '200': envelope(shift),
+        '404': envelope(object),
+        '409': envelope(object),
+        '422': envelope(object),
+    },
+    idempotent: true,
+    handler: async (ctx, url, req, params, request) => {
+        const key = keyOf(ctx, url, req);
+        if (typeof key !== 'string')
+            return key;
+        const identity = request.identity;
+        if (!(await shiftFor(ctx, url, req, params.id, identity)))
+            return notFound(ctx, url, req);
+        const result = (await ctx.call(action === 'open' ? 'pos.openSession' : 'pos.startClosing', { id: params.id, expectedRevision: request.body.expectedRevision }, url, req, commandOptions(identity, `shift.${action}`, key)));
+        if (result.ok !== true)
+            return failure(ctx, url, req, result);
+        return shiftResult(ctx, url, req, params.id, identity);
+    },
+})), defineChannelRoute({
+    profile: 'pos',
+    method: 'POST',
+    path: 'shifts/{id}/cash-movements',
+    operationId: 'pos.shifts.cashMovements.create',
+    summary: 'Record an immutable cash-in or cash-out movement in an open shift.',
+    auth: 'required',
+    capability: { key: 'pos.shifts', action: 'cash_movement' },
+    request: {
+        params: idParams,
+        body: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                expectedRevision: integer,
+                direction: string,
+                amount: string,
+                reason: string,
+                note: string,
+            },
+            required: ['expectedRevision', 'direction', 'amount', 'reason'],
+        },
+    },
+    responses: {
+        '200': envelope(shift),
+        '404': envelope(object),
+        '409': envelope(object),
+        '422': envelope(object),
+    },
+    idempotent: true,
+    handler: async (ctx, url, req, params, request) => {
+        const key = keyOf(ctx, url, req);
+        if (typeof key !== 'string')
+            return key;
+        const identity = request.identity;
+        if (!(await shiftFor(ctx, url, req, params.id, identity)))
+            return notFound(ctx, url, req);
+        const result = (await ctx.call('pos.recordCashMovement', {
+            id: channelCommandId('cash-movement', identity, `${params.id}\n${key}`),
+            sessionId: params.id,
+            expectedRevision: request.body.expectedRevision,
+            direction: request.body.direction,
+            amount: request.body.amount,
+            reason: request.body.reason,
+            note: request.body.note,
+            actorId: identity.operatorId,
+            deviceId: identity.deviceId,
+        }, url, req, commandOptions(identity, 'shift.cash-movement.create', key)));
+        if (result.ok !== true)
+            return failure(ctx, url, req, result);
+        return shiftResult(ctx, url, req, params.id, identity);
+    },
+}), defineChannelRoute({
+    profile: 'pos',
+    method: 'POST',
+    path: 'shifts/{id}/cash-movements/{movementId}/reverse',
+    operationId: 'pos.shifts.cashMovements.reverse',
+    summary: 'Correct a cash movement by appending one linked opposite movement.',
+    auth: 'required',
+    capability: { key: 'pos.shifts', action: 'cash_movement' },
+    request: {
+        params: movementParams,
+        body: {
+            type: 'object',
+            additionalProperties: false,
+            properties: { expectedRevision: integer, reason: string, note: string },
+            required: ['expectedRevision', 'reason'],
+        },
+    },
+    responses: {
+        '200': envelope(shift),
+        '404': envelope(object),
+        '409': envelope(object),
+        '422': envelope(object),
+    },
+    idempotent: true,
+    handler: async (ctx, url, req, params, request) => {
+        const key = keyOf(ctx, url, req);
+        if (typeof key !== 'string')
+            return key;
+        const identity = request.identity;
+        if (!(await shiftFor(ctx, url, req, params.id, identity)))
+            return notFound(ctx, url, req);
+        const result = (await ctx.call('pos.reverseCashMovement', {
+            id: channelCommandId('cash-movement-reversal', identity, `${params.id}\n${key}`),
+            sessionId: params.id,
+            movementId: params.movementId,
+            expectedRevision: request.body.expectedRevision,
+            reason: request.body.reason,
+            note: request.body.note,
+            actorId: identity.operatorId,
+            deviceId: identity.deviceId,
+        }, url, req, commandOptions(identity, 'shift.cash-movement.reverse', key)));
+        if (result.ok !== true)
+            return failure(ctx, url, req, result);
+        return shiftResult(ctx, url, req, params.id, identity);
+    },
+}), defineChannelRoute({
+    profile: 'pos',
+    method: 'POST',
+    path: 'shifts/{id}/close',
+    operationId: 'pos.shifts.close',
+    summary: 'Close a balanced shift or seal a variance for manager review.',
+    auth: 'required',
+    request: {
+        params: idParams,
+        body: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                expectedRevision: integer,
+                countedCash: string,
+                closingNotes: string,
+                varianceReason: string,
+                varianceNote: string,
+            },
+            required: ['expectedRevision', 'countedCash'],
+        },
+    },
+    responses: {
+        '200': envelope(shift),
+        '404': envelope(object),
+        '409': envelope(object),
+        '422': envelope(object),
+    },
+    idempotent: true,
+    handler: async (ctx, url, req, params, request) => {
+        const key = keyOf(ctx, url, req);
+        if (typeof key !== 'string')
+            return key;
+        const identity = request.identity;
+        if (!(await shiftFor(ctx, url, req, params.id, identity)))
+            return notFound(ctx, url, req);
+        const result = (await ctx.call('pos.closeSession', {
+            id: params.id,
+            expectedRevision: request.body.expectedRevision,
+            closingCash: request.body.countedCash,
+            closingNotes: request.body.closingNotes,
+            varianceReason: request.body.varianceReason,
+            varianceNote: request.body.varianceNote,
+        }, url, req, commandOptions(identity, 'shift.close', key)));
+        if (result.ok !== true)
+            return failure(ctx, url, req, result);
+        return shiftResult(ctx, url, req, params.id, identity);
+    },
+}), defineChannelRoute({
+    profile: 'pos',
+    method: 'POST',
+    path: 'shifts/{id}/variance/recount',
+    operationId: 'pos.shifts.variance.recount',
+    summary: 'Record a manager recount and close the shift when the corrected count is within tolerance.',
+    auth: 'required',
+    capability: { key: 'pos.shifts', action: 'approve_variance' },
+    request: {
+        params: idParams,
+        body: {
+            type: 'object',
+            additionalProperties: false,
+            properties: { expectedRevision: integer, countedCash: string, note: string },
+            required: ['expectedRevision', 'countedCash'],
+        },
+    },
+    responses: {
+        '200': envelope(shift),
+        '404': envelope(object),
+        '409': envelope(object),
+        '422': envelope(object),
+    },
+    idempotent: true,
+    handler: async (ctx, url, req, params, request) => {
+        const key = keyOf(ctx, url, req);
+        if (typeof key !== 'string')
+            return key;
+        const identity = request.identity;
+        if (!(await managerShiftFor(ctx, url, req, params.id, identity)))
+            return notFound(ctx, url, req);
+        const result = (await ctx.call('pos.recountSession', {
+            id: params.id,
+            expectedRevision: request.body.expectedRevision,
+            countedCash: request.body.countedCash,
+            reviewedBy: identity.operatorId,
+            note: request.body.note,
+        }, url, req, commandOptions(identity, 'shift.variance.recount', key)));
+        if (result.ok !== true)
+            return failure(ctx, url, req, result);
+        const row = (await ctx.call('pos.getSession', { id: params.id }, url, req));
+        return { data: projectShift(row), headers: { etag: `"pos-shift-${Number(row.revision ?? 0)}"` } };
+    },
+}), defineChannelRoute({
+    profile: 'pos',
+    method: 'POST',
+    path: 'shifts/{id}/variance/approve',
+    operationId: 'pos.shifts.variance.approve',
+    summary: 'Approve a sealed real variance and post a separate cash over/short adjustment.',
+    auth: 'required',
+    capability: { key: 'pos.shifts', action: 'approve_variance' },
+    request: {
+        params: idParams,
+        body: {
+            type: 'object',
+            additionalProperties: false,
+            properties: { expectedRevision: integer, note: string },
+            required: ['expectedRevision'],
+        },
+    },
+    responses: {
+        '200': envelope(shift),
+        '404': envelope(object),
+        '409': envelope(object),
+        '422': envelope(object),
+    },
+    idempotent: true,
+    handler: async (ctx, url, req, params, request) => {
+        const key = keyOf(ctx, url, req);
+        if (typeof key !== 'string')
+            return key;
+        const identity = request.identity;
+        if (!(await managerShiftFor(ctx, url, req, params.id, identity)))
+            return notFound(ctx, url, req);
+        const result = (await ctx.call('pos.approveSessionVariance', {
+            id: params.id,
+            expectedRevision: request.body.expectedRevision,
+            approvedBy: identity.operatorId,
+            note: request.body.note,
+        }, url, req, commandOptions(identity, 'shift.variance.approve', key)));
+        if (result.ok !== true)
+            return failure(ctx, url, req, result);
+        const row = (await ctx.call('pos.getSession', { id: params.id }, url, req));
+        return { data: projectShift(row), headers: { etag: `"pos-shift-${Number(row.revision ?? 0)}"` } };
+    },
+}), defineChannelRoute({
+    profile: 'pos',
+    method: 'POST',
+    path: 'orders',
+    operationId: 'pos.orders.create',
+    summary: 'Create or replay one empty revisioned POS draft owned by this device.',
+    auth: 'required',
+    request: {
+        body: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                uuid: string,
+                shiftId: string,
+                customerId: string,
+                note: string,
+                priceBookRevision: string,
+            },
+            required: ['uuid', 'shiftId', 'priceBookRevision'],
+        },
+    },
+    responses: {
+        '200': envelope(order),
+        '400': envelope(object),
+        '404': envelope(object),
+        '409': envelope(object),
+        '422': envelope(object),
+    },
+    idempotent: true,
+    handler: async (ctx, url, req, _params, request) => {
+        const key = keyOf(ctx, url, req);
+        if (typeof key !== 'string')
+            return key;
+        const identity = request.identity;
+        if (!(await shiftFor(ctx, url, req, String(request.body.shiftId), identity)))
+            return notFound(ctx, url, req);
+        const id = channelCommandId('order', identity, String(request.body.uuid));
+        const result = (await ctx.call('pos.createOrder', {
+            id,
+            uuid: request.body.uuid,
+            sessionId: request.body.shiftId,
+            partnerId: request.body.customerId,
+            note: request.body.note,
+            operatorId: identity.operatorId,
+            deviceId: identity.deviceId,
+            priceBookRevision: request.body.priceBookRevision,
+        }, url, req, commandOptions(identity, 'order.create', key)));
+        if (result.ok !== true)
+            return failure(ctx, url, req, result);
+        return orderResult(ctx, url, req, String(result.id), identity);
+    },
+}), defineChannelRoute({
+    profile: 'pos',
+    method: 'GET',
+    path: 'orders/{id}/detail',
+    operationId: 'pos.orders.get',
+    summary: 'Read one canonical revisioned POS order.',
+    auth: 'required',
+    request: { params: idParams },
+    responses: { '200': envelope(order), '404': envelope(object) },
+    handler: (ctx, url, req, params, request) => orderResult(ctx, url, req, params.id, request.identity),
+}), defineChannelRoute({
+    profile: 'pos',
+    method: 'GET',
+    path: 'orders/{id}/receipt',
+    operationId: 'pos.orders.receipt.get',
+    summary: 'Read the immutable receipt snapshot committed when this order was paid.',
+    auth: 'required',
+    request: { params: idParams },
+    responses: { '200': envelope(receipt), '404': envelope(object) },
+    handler: async (ctx, url, req, params, request) => {
+        const orderRow = await orderFor(ctx, url, req, params.id, request.identity);
+        if (!orderRow || !['paid', 'done'].includes(String(orderRow.state)))
+            return notFound(ctx, url, req);
+        const row = (await ctx.call('pos.getReceipt', { orderId: params.id }, url, req));
+        return row ? { data: projectReceipt(row) } : notFound(ctx, url, req);
+    },
+}), defineChannelRoute({
+    profile: 'pos',
+    method: 'GET',
+    path: 'orders/{id}/return-eligibility',
+    operationId: 'pos.orders.returnEligibility',
+    summary: 'Read remaining return capacity from the immutable sale and its return history.',
+    auth: 'required',
+    request: { params: idParams },
+    responses: {
+        '200': envelope(returnEligibility),
+        '404': envelope(object),
+        '422': envelope(object),
+    },
+    handler: async (ctx, url, req, params, request) => {
+        const identity = request.identity;
+        if (!(await orderFor(ctx, url, req, params.id, identity)))
+            return notFound(ctx, url, req);
+        const result = (await ctx.call('pos.getReturnEligibility', { id: params.id }, url, req));
+        if (result.ok !== true)
+            return failure(ctx, url, req, result);
+        const data = {
+            originalOrderId: String(result.originalOrderId),
+            revision: Number(result.revision),
+            refundable: Boolean(result.refundable),
+            requiresFullReturn: Boolean(result.requiresFullReturn),
+            standaloneAllowed: Boolean(result.standaloneAllowed),
+            lines: Array.isArray(result.lines) ? result.lines : [],
+        };
+        return { data, headers: { etag: `"pos-return-${data.revision}"` } };
+    },
+}), defineChannelRoute({
+    profile: 'pos',
+    method: 'POST',
+    path: 'orders/{id}/returns',
+    operationId: 'pos.orders.returns.create',
+    summary: 'Create an immutable partial-return draft against remaining sale quantities.',
+    auth: 'required',
+    request: {
+        params: idParams,
+        body: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                shiftId: string,
+                expectedRevision: integer,
+                lines: {
+                    type: 'array',
+                    minItems: 1,
+                    items: {
+                        type: 'object',
+                        additionalProperties: false,
+                        properties: { lineId: string, quantity: string },
+                        required: ['lineId', 'quantity'],
+                    },
+                },
+            },
+            required: ['shiftId', 'expectedRevision', 'lines'],
+        },
+    },
+    responses: {
+        '200': envelope(order),
+        '400': envelope(object),
+        '404': envelope(object),
+        '409': envelope(object),
+        '422': envelope(object),
+    },
+    idempotent: true,
+    handler: async (ctx, url, req, params, request) => {
+        const key = keyOf(ctx, url, req);
+        if (typeof key !== 'string')
+            return key;
+        const identity = request.identity;
+        const original = await orderFor(ctx, url, req, params.id, identity);
+        const shift = await shiftFor(ctx, url, req, String(request.body.shiftId), identity);
+        if (!original || !shift)
+            return notFound(ctx, url, req);
+        const id = channelCommandId('return', identity, `${params.id}\n${key}`);
+        const functionName = await lifecycleFunction(ctx, req, 'loyalty_pos.refundOrder', 'pos.refundOrder');
+        const result = (await ctx.call(functionName, {
+            id,
+            uuid: id,
+            originalOrderId: params.id,
+            sessionId: request.body.shiftId,
+            expectedRevision: request.body.expectedRevision,
+            lines: request.body.lines,
+            operatorId: identity.operatorId,
+            deviceId: identity.deviceId,
+        }, url, req, commandOptions(identity, 'order.return.create', key)));
+        if (result.ok !== true)
+            return failure(ctx, url, req, result);
+        return orderResult(ctx, url, req, String(result.id), identity);
+    },
+}), defineChannelRoute({
+    profile: 'pos',
+    method: 'POST',
+    path: 'orders/{id}/exchanges',
+    operationId: 'pos.orders.exchanges.create',
+    summary: 'Create linked return and replacement drafts for one paid sale.',
+    auth: 'required',
+    request: {
+        params: idParams,
+        body: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                uuid: string,
+                shiftId: string,
+                expectedRevision: integer,
+                reason: string,
+                lines: {
+                    type: 'array',
+                    minItems: 1,
+                    items: {
+                        type: 'object',
+                        additionalProperties: false,
+                        properties: { lineId: string, quantity: string },
+                        required: ['lineId', 'quantity'],
+                    },
+                },
+                replacement: {
+                    type: 'object',
+                    additionalProperties: false,
+                    properties: { priceBookRevision: string, note: string },
+                    required: ['priceBookRevision'],
+                },
+            },
+            required: ['uuid', 'shiftId', 'expectedRevision', 'reason', 'lines', 'replacement'],
+        },
+    },
+    responses: {
+        '200': envelope(exchangeDraft),
+        '400': envelope(object),
+        '404': envelope(object),
+        '409': envelope(object),
+        '422': envelope(object),
+    },
+    idempotent: true,
+    handler: async (ctx, url, req, params, request) => {
+        const key = keyOf(ctx, url, req);
+        if (typeof key !== 'string')
+            return key;
+        const identity = request.identity;
+        const original = await orderFor(ctx, url, req, params.id, identity);
+        const shift = await shiftFor(ctx, url, req, String(request.body.shiftId), identity);
+        if (!original || !shift)
+            return notFound(ctx, url, req);
+        const id = channelCommandId('exchange', identity, String(request.body.uuid));
+        const functionName = await lifecycleFunction(ctx, req, 'loyalty_pos.createExchange', 'pos.createExchange');
+        const result = (await ctx.call(functionName, {
+            id,
+            uuid: request.body.uuid,
+            originalOrderId: params.id,
+            sessionId: request.body.shiftId,
+            expectedRevision: request.body.expectedRevision,
+            lines: request.body.lines,
+            reason: request.body.reason,
+            replacementPriceBookRevision: request.body.replacement.priceBookRevision,
+            replacementNote: request.body.replacement.note,
+            operatorId: identity.operatorId,
+            deviceId: identity.deviceId,
+        }, url, req, commandOptions(identity, 'order.exchange.create', key)));
+        if (result.ok !== true)
+            return failure(ctx, url, req, result);
+        const returnRow = await orderFor(ctx, url, req, String(result.returnOrderId), identity);
+        const replacementRow = await orderFor(ctx, url, req, String(result.replacementOrderId), identity);
+        if (!returnRow || !replacementRow)
+            return notFound(ctx, url, req);
+        const data = {
+            id: String(result.id),
+            uuid: String(result.uuid),
+            originalOrderId: String(result.originalOrderId),
+            returnOrderId: String(result.returnOrderId),
+            replacementOrderId: String(result.replacementOrderId),
+            originalRevision: Number(result.originalRevision),
+            reason: String(result.reason),
+            createdAt: String(result.createdAt),
+            returnOrder: projectOrder(returnRow),
+            replacementOrder: projectOrder(replacementRow),
+        };
+        return {
+            data,
+            headers: {
+                etag: `"pos-exchange-${data.returnOrder.revision}-${data.replacementOrder.revision}"`,
+            },
+        };
+    },
+}), defineChannelRoute({
+    profile: 'pos',
+    method: 'PATCH',
+    path: 'orders/{id}/update',
+    operationId: 'pos.orders.update',
+    summary: 'Update customer or note under the order revision.',
+    auth: 'required',
+    request: {
+        params: idParams,
+        body: {
+            type: 'object',
+            additionalProperties: false,
+            properties: { expectedRevision: integer, customerId: nullableString, note: string },
+            required: ['expectedRevision'],
+        },
+    },
+    responses: {
+        '200': envelope(order),
+        '404': envelope(object),
+        '409': envelope(object),
+        '422': envelope(object),
+    },
+    idempotent: true,
+    handler: async (ctx, url, req, params, request) => {
+        const key = keyOf(ctx, url, req);
+        if (typeof key !== 'string')
+            return key;
+        const identity = request.identity;
+        if (!(await orderFor(ctx, url, req, params.id, identity)))
+            return notFound(ctx, url, req);
+        const result = (await ctx.call('pos.updateOrder', {
+            id: params.id,
+            expectedRevision: request.body.expectedRevision,
+            partnerId: request.body.customerId ?? undefined,
+            clearPartner: request.body.customerId === null,
+            note: request.body.note,
+        }, url, req, commandOptions(identity, 'order.update', key)));
+        if (result.ok !== true)
+            return failure(ctx, url, req, result);
+        return orderResult(ctx, url, req, params.id, identity);
+    },
+}), defineChannelRoute({
+    profile: 'pos',
+    method: 'POST',
+    path: 'orders/{id}/lines',
+    operationId: 'pos.orders.lines.add',
+    summary: 'Add one canonically quoted line under the order revision.',
+    auth: 'required',
+    request: {
+        params: idParams,
+        body: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                expectedRevision: integer,
+                productId: string,
+                uomId: string,
+                quantity: string,
+                quoteRevision: string,
+            },
+            required: ['expectedRevision', 'productId', 'uomId', 'quantity', 'quoteRevision'],
+        },
+    },
+    responses: {
+        '200': envelope(order),
+        '404': envelope(object),
+        '409': envelope(object),
+        '422': envelope(object),
+    },
+    idempotent: true,
+    handler: async (ctx, url, req, params, request) => {
+        const key = keyOf(ctx, url, req);
+        if (typeof key !== 'string')
+            return key;
+        const identity = request.identity;
+        const held = await orderFor(ctx, url, req, params.id, identity);
+        if (!held)
+            return notFound(ctx, url, req);
+        const current = (await ctx.call('pos_channel.priceBook', { posConfigId: identity.posConfigId, limit: 1 }, url, req));
+        if (String(held.priceBookRevision ?? '') !== String(request.body.quoteRevision) ||
+            String(current.revision ?? '') !== String(request.body.quoteRevision))
+            return failure(ctx, url, req, invalid('quoteRevision', 'the price book changed; reload it'));
+        const result = (await ctx.call('pos.addLine', {
+            id: channelCommandId('line', identity, `${params.id}\n${key}`),
+            orderId: params.id,
+            productId: request.body.productId,
+            productUomId: request.body.uomId,
+            qty: request.body.quantity,
+            quoteRevision: request.body.quoteRevision,
+            expectedRevision: request.body.expectedRevision,
+        }, url, req, commandOptions(identity, 'order.line.add', key)));
+        if (result.ok !== true)
+            return failure(ctx, url, req, result);
+        return orderResult(ctx, url, req, params.id, identity);
+    },
+}), defineChannelRoute({
+    profile: 'pos',
+    method: 'PATCH',
+    path: 'orders/{id}/lines/{lineId}/update',
+    operationId: 'pos.orders.lines.update',
+    summary: 'Requote and update one member line under the order revision.',
+    auth: 'required',
+    request: {
+        params: lineParams,
+        body: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                expectedRevision: integer,
+                quantity: string,
+                quoteRevision: string,
+                sequence: integer,
+            },
+            required: ['expectedRevision', 'quantity'],
+        },
+    },
+    responses: {
+        '200': envelope(order),
+        '404': envelope(object),
+        '409': envelope(object),
+        '422': envelope(object),
+    },
+    idempotent: true,
+    handler: async (ctx, url, req, params, request) => {
+        const key = keyOf(ctx, url, req);
+        if (typeof key !== 'string')
+            return key;
+        const identity = request.identity;
+        if (!(await orderFor(ctx, url, req, params.id, identity)))
+            return notFound(ctx, url, req);
+        const result = (await ctx.call('pos.updateLine', {
+            id: params.lineId,
+            orderId: params.id,
+            expectedRevision: request.body.expectedRevision,
+            qty: request.body.quantity,
+            quoteRevision: request.body.quoteRevision,
+            sequence: request.body.sequence,
+        }, url, req, commandOptions(identity, 'order.line.update', key)));
+        if (result.ok !== true)
+            return failure(ctx, url, req, result);
+        return orderResult(ctx, url, req, params.id, identity);
+    },
+}), defineChannelRoute({
+    profile: 'pos',
+    method: 'GET',
+    path: 'orders/{id}/lines/{lineId}/lot-availability',
+    operationId: 'pos.orders.lines.lotAvailability',
+    summary: 'Read warehouse-scoped lot or serial availability for one tracked order line.',
+    auth: 'required',
+    request: { params: lineParams },
+    responses: {
+        '200': envelope(lotAvailability),
+        '404': envelope(object),
+        '409': envelope(object),
+        '422': envelope(object),
+    },
+    handler: async (ctx, url, req, params, request) => {
+        const identity = request.identity;
+        if (!(await orderFor(ctx, url, req, params.id, identity)))
+            return notFound(ctx, url, req);
+        const held = (await ctx.call('pos.getLineTrackingAvailability', { orderId: params.id, lineId: params.lineId }, url, req));
+        return held ? { data: held } : notFound(ctx, url, req);
+    },
+}), defineChannelRoute({
+    profile: 'pos',
+    method: 'PUT',
+    path: 'orders/{id}/lines/{lineId}/lot-selections',
+    operationId: 'pos.orders.lines.lots.select',
+    summary: 'Persist an exact revision-bound lot or serial selection on one draft line.',
+    auth: 'required',
+    request: {
+        params: lineParams,
+        body: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                expectedRevision: integer,
+                selections: {
+                    type: 'array',
+                    minItems: 1,
+                    items: {
+                        type: 'object',
+                        additionalProperties: false,
+                        properties: { lotId: string, quantity: string, stockRevision: string },
+                        required: ['lotId', 'quantity', 'stockRevision'],
+                    },
+                },
+            },
+            required: ['expectedRevision', 'selections'],
+        },
+    },
+    responses: {
+        '200': envelope(order),
+        '404': envelope(object),
+        '409': envelope(object),
+        '422': envelope(object),
+    },
+    idempotent: true,
+    handler: async (ctx, url, req, params, request) => {
+        const key = keyOf(ctx, url, req);
+        if (typeof key !== 'string')
+            return key;
+        const identity = request.identity;
+        if (!(await orderFor(ctx, url, req, params.id, identity)))
+            return notFound(ctx, url, req);
+        const result = (await ctx.call('pos.setLineLotSelections', {
+            orderId: params.id,
+            lineId: params.lineId,
+            expectedRevision: request.body.expectedRevision,
+            selections: request.body.selections,
+        }, url, req, commandOptions(identity, 'order.line.lots.select', key)));
+        if (result.ok !== true)
+            return failure(ctx, url, req, result);
+        return orderResult(ctx, url, req, params.id, identity);
+    },
+}), ...['discount', 'price-override'].map((action) => defineChannelRoute({
+    profile: 'pos',
+    method: 'POST',
+    path: `orders/{id}/lines/{lineId}/${action}`,
+    operationId: `pos.orders.lines.${action === 'discount' ? 'discount' : 'priceOverride'}`,
+    summary: action === 'discount'
+        ? 'Apply a staff-authorized line discount.'
+        : 'Apply a manager-authorized manual unit price with an audit reason.',
+    auth: 'required',
+    capability: {
+        key: 'pos.orders',
+        action: action === 'discount' ? 'discount' : 'override_price',
+    },
+    request: {
+        params: lineParams,
+        body: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                expectedRevision: integer,
+                ...(action === 'discount' ? { discount: string } : { unitPrice: string, reason: string }),
+            },
+            required: action === 'discount'
+                ? ['expectedRevision', 'discount']
+                : ['expectedRevision', 'unitPrice', 'reason'],
+        },
+    },
+    responses: {
+        '200': envelope(order),
+        '404': envelope(object),
+        '409': envelope(object),
+        '422': envelope(object),
+    },
+    idempotent: true,
+    handler: async (ctx, url, req, params, request) => {
+        const key = keyOf(ctx, url, req);
+        if (typeof key !== 'string')
+            return key;
+        const identity = request.identity;
+        const held = await orderFor(ctx, url, req, params.id, identity);
+        if (!held)
+            return notFound(ctx, url, req);
+        const line = (Array.isArray(held.lines) ? held.lines : []).find((candidate) => String(candidate.id) === params.lineId);
+        if (!line)
+            return notFound(ctx, url, req);
+        const result = (await ctx.call('pos.updateLine', {
+            id: params.lineId,
+            orderId: params.id,
+            expectedRevision: request.body.expectedRevision,
+            qty: line.qty,
+            ...(action === 'discount'
+                ? { discount: request.body.discount }
+                : {
+                    priceUnit: request.body.unitPrice,
+                    overrideReason: request.body.reason,
+                }),
+            overrideBy: identity.operatorId,
+        }, url, req, commandOptions(identity, `order.line.${action}`, key)));
+        if (result.ok !== true)
+            return failure(ctx, url, req, result);
+        return orderResult(ctx, url, req, params.id, identity);
+    },
+})), defineChannelRoute({
+    profile: 'pos',
+    method: 'DELETE',
+    path: 'orders/{id}/lines/{lineId}/remove',
+    operationId: 'pos.orders.lines.remove',
+    summary: 'Remove one member line under the order revision.',
+    auth: 'required',
+    request: { params: lineParams, body: expectedBody },
+    responses: {
+        '200': envelope(order),
+        '404': envelope(object),
+        '409': envelope(object),
+        '422': envelope(object),
+    },
+    idempotent: true,
+    handler: async (ctx, url, req, params, request) => {
+        const key = keyOf(ctx, url, req);
+        if (typeof key !== 'string')
+            return key;
+        const identity = request.identity;
+        if (!(await orderFor(ctx, url, req, params.id, identity)))
+            return notFound(ctx, url, req);
+        const result = (await ctx.call('pos.removeLine', { id: params.lineId, orderId: params.id, expectedRevision: request.body.expectedRevision }, url, req, commandOptions(identity, 'order.line.remove', key)));
+        if (result.ok !== true)
+            return failure(ctx, url, req, result);
+        return orderResult(ctx, url, req, params.id, identity);
+    },
+}), defineChannelRoute({
+    profile: 'pos',
+    method: 'POST',
+    path: 'orders/{id}/lines/reorder',
+    operationId: 'pos.orders.lines.reorder',
+    summary: 'Replace line order using an exact membership list.',
+    auth: 'required',
+    request: {
+        params: idParams,
+        body: {
+            type: 'object',
+            additionalProperties: false,
+            properties: { expectedRevision: integer, lineIds: { type: 'array', items: string } },
+            required: ['expectedRevision', 'lineIds'],
+        },
+    },
+    responses: {
+        '200': envelope(order),
+        '404': envelope(object),
+        '409': envelope(object),
+        '422': envelope(object),
+    },
+    idempotent: true,
+    handler: async (ctx, url, req, params, request) => {
+        const key = keyOf(ctx, url, req);
+        if (typeof key !== 'string')
+            return key;
+        const identity = request.identity;
+        if (!(await orderFor(ctx, url, req, params.id, identity)))
+            return notFound(ctx, url, req);
+        const result = (await ctx.call('pos.reorderLines', { id: params.id, expectedRevision: request.body.expectedRevision, lineIds: request.body.lineIds }, url, req, commandOptions(identity, 'order.line.reorder', key)));
+        if (result.ok !== true)
+            return failure(ctx, url, req, result);
+        return orderResult(ctx, url, req, params.id, identity);
+    },
+}), defineChannelRoute({
+    profile: 'pos',
+    method: 'POST',
+    path: 'orders/{id}/tenders',
+    operationId: 'pos.orders.tenders.add',
+    summary: 'Capture one cash or manual non-cash tender under the order revision.',
+    auth: 'required',
+    request: {
+        params: idParams,
+        body: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                expectedRevision: integer,
+                paymentMethodId: string,
+                tenderedAmount: string,
+                reference: string,
+            },
+            required: ['expectedRevision', 'paymentMethodId', 'tenderedAmount'],
+        },
+    },
+    responses: {
+        '200': envelope(order),
+        '404': envelope(object),
+        '409': envelope(object),
+        '422': envelope(object),
+    },
+    idempotent: true,
+    handler: async (ctx, url, req, params, request) => {
+        const key = keyOf(ctx, url, req);
+        if (typeof key !== 'string')
+            return key;
+        const identity = request.identity;
+        if (!(await orderFor(ctx, url, req, params.id, identity)))
+            return notFound(ctx, url, req);
+        const result = (await ctx.call('pos.addPayment', {
+            id: channelCommandId('tender', identity, `${params.id}\n${key}`),
+            orderId: params.id,
+            expectedRevision: request.body.expectedRevision,
+            paymentMethodId: request.body.paymentMethodId,
+            tenderedAmount: request.body.tenderedAmount,
+            reference: request.body.reference,
+            operatorId: identity.operatorId,
+            deviceId: identity.deviceId,
+        }, url, req, commandOptions(identity, 'order.tender.add', key)));
+        if (result.ok !== true)
+            return failure(ctx, url, req, result);
+        return orderResult(ctx, url, req, params.id, identity);
+    },
+}), defineChannelRoute({
+    profile: 'pos',
+    method: 'POST',
+    path: 'orders/{id}/tenders/{tenderId}/void',
+    operationId: 'pos.orders.tenders.void',
+    summary: 'Void one captured tender before finalization.',
+    auth: 'required',
+    request: {
+        params: tenderParams,
+        body: {
+            type: 'object',
+            additionalProperties: false,
+            properties: { expectedRevision: integer, reason: string },
+            required: ['expectedRevision', 'reason'],
+        },
+    },
+    responses: {
+        '200': envelope(order),
+        '404': envelope(object),
+        '409': envelope(object),
+        '422': envelope(object),
+    },
+    idempotent: true,
+    handler: async (ctx, url, req, params, request) => {
+        const key = keyOf(ctx, url, req);
+        if (typeof key !== 'string')
+            return key;
+        const identity = request.identity;
+        if (!(await orderFor(ctx, url, req, params.id, identity)))
+            return notFound(ctx, url, req);
+        const result = (await ctx.call('pos.voidPayment', {
+            id: params.tenderId,
+            orderId: params.id,
+            expectedRevision: request.body.expectedRevision,
+            reason: request.body.reason,
+            operatorId: identity.operatorId,
+        }, url, req, commandOptions(identity, 'order.tender.void', key)));
+        if (result.ok !== true)
+            return failure(ctx, url, req, result);
+        return orderResult(ctx, url, req, params.id, identity);
+    },
+}), defineChannelRoute({
+    profile: 'pos',
+    method: 'POST',
+    path: 'orders/{id}/finalize',
+    operationId: 'pos.orders.finalize',
+    summary: 'Finalize one fully covered order into stock, invoice and reconciled accounting.',
+    auth: 'required',
+    request: { params: idParams, body: expectedBody },
+    responses: {
+        '200': envelope(order),
+        '404': envelope(object),
+        '409': envelope(object),
+        '422': envelope(object),
+    },
+    idempotent: true,
+    handler: async (ctx, url, req, params, request) => {
+        const key = keyOf(ctx, url, req);
+        if (typeof key !== 'string')
+            return key;
+        const identity = request.identity;
+        if (!(await orderFor(ctx, url, req, params.id, identity)))
+            return notFound(ctx, url, req);
+        const result = (await ctx.call(await lifecycleFunction(ctx, req, 'loyalty_pos.validateOrder', 'pos.validateOrder'), { id: params.id, expectedRevision: request.body.expectedRevision }, url, req, commandOptions(identity, 'order.finalize', key)));
+        if (result.ok !== true)
+            return failure(ctx, url, req, result);
+        return orderResult(ctx, url, req, params.id, identity);
+    },
+}), defineChannelRoute({
+    profile: 'pos',
+    method: 'POST',
+    path: 'orders/{id}/cancel',
+    operationId: 'pos.orders.cancel',
+    summary: 'Cancel one draft under the order revision.',
+    auth: 'required',
+    request: { params: idParams, body: expectedBody },
+    responses: {
+        '200': envelope(order),
+        '404': envelope(object),
+        '409': envelope(object),
+        '422': envelope(object),
+    },
+    idempotent: true,
+    handler: async (ctx, url, req, params, request) => {
+        const key = keyOf(ctx, url, req);
+        if (typeof key !== 'string')
+            return key;
+        const identity = request.identity;
+        if (!(await orderFor(ctx, url, req, params.id, identity)))
+            return notFound(ctx, url, req);
+        const result = (await ctx.call(await lifecycleFunction(ctx, req, 'loyalty_pos.cancelOrder', 'pos.cancelOrder'), { id: params.id, expectedRevision: request.body.expectedRevision }, url, req, commandOptions(identity, 'order.cancel', key)));
+        if (result.ok !== true)
+            return failure(ctx, url, req, result);
+        return orderResult(ctx, url, req, params.id, identity);
+    },
+}));
+export { commandOptions, failure as posFailure, keyOf as posCommandKey, lifecycleFunction as posLifecycleFunction, notFound as posNotFound, orderFor as posOrderFor, projectOrder as posProjectOrder, projectShift as posProjectShift, order as posOrderSchema, shift as posShiftSchema, shiftFor as posShiftFor, };
+//# sourceMappingURL=operations.js.map