@rytass/wms-module-graphql 0.7.0 → 0.9.0

package/index.cjs.js

@@ -12,7 +12,6 @@ var graphql = require('@nestjs/graphql');
 var core = require('@nestjs/core');
 var rxjs = require('rxjs');
 var wmsBaseNestjsModule = require('@rytass/wms-base-nestjs-module');
-var warehouseMap_entity = require('@rytass/wms-base-nestjs-module/models/warehouse-map.entity');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -466,6 +465,138 @@ exports.WmsMutationInterceptor = tslib.__decorate([
  */
 const WmsMutationEvent = (config) => common.applyDecorators(common.SetMetadata(WMS_MUTATION_EVENT_METADATA, config), common.UseInterceptors(exports.WmsMutationInterceptor));
 
+function resolveDisabled(options) {
+    const { enabledOperations, disabledOperations, disabledFields } = options;
+    if (enabledOperations && disabledOperations) {
+        throw new Error('[wms-module-graphql] `enabledOperations` and `disabledOperations` are mutually exclusive — pass one or the other, not both.');
+    }
+    const enabled = enabledOperations ? new Set(enabledOperations) : null;
+    const disabled = disabledOperations
+        ? new Set(disabledOperations)
+        : null;
+    const fields = new Set(disabledFields ?? []);
+    return {
+        hasSwitches: enabled !== null || disabled !== null || fields.size > 0,
+        isOperationDisabled: (name) => {
+            if (enabled) {
+                return !enabled.has(name);
+            }
+            if (disabled) {
+                return disabled.has(name);
+            }
+            return false;
+        },
+        disabledFields: fields,
+    };
+}
+/** Methods already pruned, so the metadata filter can drop their entries. */
+const prunedMethods = new WeakMap();
+let metadataFilterInstalled = false;
+/**
+ * Stop the pruned operations from ever entering `TypeMetadataStorage`.
+ *
+ * The resolver metadata is **lazy**: `@Query()` / `@Mutation()` only register a
+ * thunk with `LazyMetadataStorage`, and the thunk calls `add*Metadata` when
+ * `GraphQLSchemaBuilder.build()` loads it. At `forRootAsync` time the storage
+ * arrays are therefore still empty, and filtering them then would remove
+ * nothing — so the filter has to sit on the writes instead.
+ */
+function installMetadataFilter() {
+    if (metadataFilterInstalled) {
+        return;
+    }
+    const storage = graphql.TypeMetadataStorage;
+    const addQuery = storage.addQueryMetadata.bind(storage);
+    const addMutation = storage.addMutationMetadata.bind(storage);
+    const isPruned = (metadata) => prunedMethods.get(metadata.target)?.has(metadata.methodName) === true;
+    storage.addQueryMetadata = (metadata) => {
+        if (isPruned(metadata)) {
+            return;
+        }
+        addQuery(metadata);
+    };
+    storage.addMutationMetadata = (metadata) => {
+        if (isPruned(metadata)) {
+            return;
+        }
+        addMutation(metadata);
+    };
+    metadataFilterInstalled = true;
+}
+/** The GraphQL field name a root handler ends up under. */
+function schemaNameOf(handler, methodName) {
+    const explicit = Reflect.getMetadata(graphql.RESOLVER_NAME_METADATA, handler);
+    return explicit || methodName;
+}
+/**
+ * Remove the switched-off root operations before the schema is built.
+ *
+ * Two edits are needed, at two different moments, and they must happen together:
+ *
+ * 1. **now** — `delete Resolver.prototype[method]`, because
+ *    `ResolversExplorerService.explore()` walks the prototype with
+ *    `MetadataScanner` and runs *before* the schema builder loads the lazy
+ *    metadata. Leaving the method in place would put `Query.foo` in the resolver
+ *    map with no matching field in the typeDefs, and `makeExecutableSchema`
+ *    rejects the whole schema (`requireResolversToMatchSchema`).
+ * 2. **at load time** — drop the metadata entry ({@link installMetadataFilter}),
+ *    or the SDL would still declare a field that resolves to `null`: present,
+ *    but dead.
+ *
+ * Deleting the prototype method does not disturb step 2's type reflection:
+ * `design:returntype` is stored against the prototype and property key, not
+ * against the function object, so it survives the delete.
+ *
+ * This runs synchronously from `forRootAsync`, i.e. while `AppModule` is still
+ * being defined. Both the classes and the storage are process-global, so a
+ * process may register `WmsModuleGraphqlModule` only once.
+ */
+function pruneDisabledOperations(resolverClasses, options) {
+    const { hasSwitches, isOperationDisabled, disabledFields } = resolveDisabled(options);
+    if (!hasSwitches) {
+        return { queries: [], mutations: [] };
+    }
+    installMetadataFilter();
+    const queries = [];
+    const mutations = [];
+    for (const resolverClass of resolverClasses) {
+        const prototype = resolverClass.prototype;
+        if (!prototype) {
+            continue;
+        }
+        for (const methodName of Object.getOwnPropertyNames(prototype)) {
+            if (methodName === 'constructor') {
+                continue;
+            }
+            const handler = prototype[methodName];
+            if (typeof handler !== 'function') {
+                continue;
+            }
+            const resolverType = Reflect.getMetadata(graphql.RESOLVER_TYPE_METADATA, handler);
+            // Only root operations are switchable. `@ResolveField` handlers are
+            // reached exclusively through an already-registered root field, so
+            // removing one would break the type rather than the deployment surface.
+            if (resolverType !== 'Query' && resolverType !== 'Mutation') {
+                continue;
+            }
+            const schemaName = schemaNameOf(handler, methodName);
+            const requirement = Reflect.getMetadata(WMS_OPERATION_METADATA, handler);
+            const disabled = disabledFields.has(schemaName) ||
+                (requirement !== undefined &&
+                    isOperationDisabled(`${requirement.resource}:${requirement.action}`));
+            if (!disabled) {
+                continue;
+            }
+            const alreadyPruned = prunedMethods.get(resolverClass) ?? new Set();
+            alreadyPruned.add(methodName);
+            prunedMethods.set(resolverClass, alreadyPruned);
+            delete prototype[methodName];
+            (resolverType === 'Query' ? queries : mutations).push(schemaName);
+        }
+    }
+    return { queries, mutations };
+}
+
 const IdGenFunction = (input) => {
     const hash = crypto.createHash('sha256');
     hash.update(input);
@@ -1603,6 +1734,146 @@ QualityInspectionOrders = tslib.__decorate([
     graphql.ObjectType()
 ], QualityInspectionOrders);
 
+graphql.registerEnumType(wmsModuleCore.InventoryCountStatus, {
+    name: 'InventoryCountStatus',
+    description: 'Lifecycle of an inventory count: PENDING (尚未執行) → COUNTING (盤點中) → COMPLETED (已完成), or CANCELLED (已取消).',
+});
+/**
+ * A count-sheet line.
+ *
+ * `material` / `batch` / `location` / `loader` are deliberately absent from this
+ * class: they are added to the schema by `InventoryCountOrderItemResolver` as
+ * `@ResolveField`s so they load through DataLoaders, and declaring them here
+ * would make the class stop matching the entity the service returns.
+ */
+let InventoryCountOrderItemDto = class InventoryCountOrderItemDto {
+    id;
+    orderId;
+    materialId;
+    batchId;
+    locationId;
+    loaderId;
+    unitId;
+    /** Ledger quantity in base units, frozen when counting started. */
+    bookQuantity;
+    /** What was found, expressed in `unitId`. `null` until someone counts it. */
+    countedQuantity;
+    /** `true` for a line added during counting for stock the books never had. */
+    isAddition;
+};
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], InventoryCountOrderItemDto.prototype, "id", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], InventoryCountOrderItemDto.prototype, "orderId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], InventoryCountOrderItemDto.prototype, "materialId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], InventoryCountOrderItemDto.prototype, "batchId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], InventoryCountOrderItemDto.prototype, "locationId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], InventoryCountOrderItemDto.prototype, "loaderId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], InventoryCountOrderItemDto.prototype, "unitId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.Float),
+    tslib.__metadata("design:type", Number)
+], InventoryCountOrderItemDto.prototype, "bookQuantity", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.Float, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], InventoryCountOrderItemDto.prototype, "countedQuantity", void 0);
+tslib.__decorate([
+    graphql.Field(() => Boolean),
+    tslib.__metadata("design:type", Boolean)
+], InventoryCountOrderItemDto.prototype, "isAddition", void 0);
+InventoryCountOrderItemDto = tslib.__decorate([
+    graphql.ObjectType()
+], InventoryCountOrderItemDto);
+/**
+ * A count order. `items` and `locations` come from
+ * `InventoryCountOrderResolver`, for the same reason as above; `locations`
+ * exposes the roots the user picked, not the expanded subtree.
+ */
+let InventoryCountOrderDto = class InventoryCountOrderDto {
+    id;
+    key;
+    name;
+    /**
+     * The count's base date. Stock adjustments from settlement are reported under
+     * this date rather than the day settlement happened to run.
+     */
+    countDate;
+    status;
+    createdBy;
+    startedAt;
+    settledAt;
+    cancelledAt;
+    createdAt;
+};
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], InventoryCountOrderDto.prototype, "id", void 0);
+tslib.__decorate([
+    graphql.Field(() => String),
+    tslib.__metadata("design:type", String)
+], InventoryCountOrderDto.prototype, "key", void 0);
+tslib.__decorate([
+    graphql.Field(() => String),
+    tslib.__metadata("design:type", String)
+], InventoryCountOrderDto.prototype, "name", void 0);
+tslib.__decorate([
+    graphql.Field(() => String),
+    tslib.__metadata("design:type", String)
+], InventoryCountOrderDto.prototype, "countDate", void 0);
+tslib.__decorate([
+    graphql.Field(() => wmsModuleCore.InventoryCountStatus),
+    tslib.__metadata("design:type", String)
+], InventoryCountOrderDto.prototype, "status", void 0);
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], InventoryCountOrderDto.prototype, "createdBy", void 0);
+tslib.__decorate([
+    graphql.Field(() => Date, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], InventoryCountOrderDto.prototype, "startedAt", void 0);
+tslib.__decorate([
+    graphql.Field(() => Date, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], InventoryCountOrderDto.prototype, "settledAt", void 0);
+tslib.__decorate([
+    graphql.Field(() => Date, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], InventoryCountOrderDto.prototype, "cancelledAt", void 0);
+tslib.__decorate([
+    graphql.Field(() => Date),
+    tslib.__metadata("design:type", Date)
+], InventoryCountOrderDto.prototype, "createdAt", void 0);
+InventoryCountOrderDto = tslib.__decorate([
+    graphql.ObjectType()
+], InventoryCountOrderDto);
+let InventoryCountOrders = class InventoryCountOrders extends PaginatedResponse(InventoryCountOrderDto) {
+};
+InventoryCountOrders = tslib.__decorate([
+    graphql.ObjectType()
+], InventoryCountOrders);
+
 let CreateLoaderTypeArgs = class CreateLoaderTypeArgs {
     description;
     key;
@@ -3137,8 +3408,17 @@ Locations = tslib.__decorate([
 ], Locations);
 
 let LoaderResolver = class LoaderResolver {
+    entities;
     stockService;
-    constructor(stockService) {
+    /**
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`. Loading a built-in class outright filters
+     * on its single-table-inheritance discriminator and resolves nothing for an
+     * override.
+     */
+    constructor(entities, stockService) {
+        this.entities = entities;
         this.stockService = stockService;
     }
     type({ typeId }, { loaders }) {
@@ -3149,7 +3429,7 @@ let LoaderResolver = class LoaderResolver {
     }
     location({ locationId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: wmsModuleCore.LocationEntityClass,
+            __entity: this.entities.location,
             __from: { id: locationId },
         });
     }
@@ -3188,7 +3468,8 @@ tslib.__decorate([
 ], LoaderResolver.prototype, "totalQuantity", null);
 LoaderResolver = tslib.__decorate([
     graphql.Resolver(() => LoaderDto),
-    tslib.__metadata("design:paramtypes", [wmsModuleCore.StockService])
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.WmsEntities,
+        wmsModuleCore.StockService])
 ], LoaderResolver);
 
 let UnitDto = class UnitDto {
@@ -3283,32 +3564,32 @@ Batches = tslib.__decorate([
 ], Batches);
 
 let StockResolver = class StockResolver {
-    materialEntity;
+    entities;
     /**
-     * Bound to the `MaterialEntity` Symbol, so the DataLoader queries whichever
-     * material entity the consumer configured — the built-in `MaterialEntityClass`
-     * unless `materialEntity` was passed to `forRoot`/`forRootAsync`. Loading the
-     * built-in class outright would filter on its single-table-inheritance
-     * discriminator and resolve nothing for a custom entity.
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`. Loading a built-in class outright filters
+     * on its single-table-inheritance discriminator and resolves nothing for an
+     * override.
      */
-    constructor(materialEntity) {
-        this.materialEntity = materialEntity;
+    constructor(entities) {
+        this.entities = entities;
     }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: this.materialEntity,
+            __entity: this.entities.material,
             __from: { id: materialId },
         });
     }
     location({ locationId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: wmsModuleCore.LocationEntityClass,
+            __entity: this.entities.location,
             __from: { id: locationId },
         });
     }
     async batch({ batchId }, { loaders }) {
         const { groupId } = await loaders.batchSingle.load({
-            __entity: wmsModuleCore.BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         });
         return loaders.batchSingle.load({
@@ -3343,8 +3624,7 @@ tslib.__decorate([
 ], StockResolver.prototype, "batch", null);
 StockResolver = tslib.__decorate([
     graphql.Resolver(() => StockDto),
-    tslib.__param(0, common.Inject(wmsModuleCore.MaterialEntity)),
-    tslib.__metadata("design:paramtypes", [Function])
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.WmsEntities])
 ], StockResolver);
 
 var MapRangeType;
@@ -3671,9 +3951,20 @@ WarehouseMapMutation = tslib.__decorate([
 ], WarehouseMapMutation);
 
 let LocationResolver = class LocationResolver {
+    entities;
+    /**
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`. Loading a built-in class outright filters
+     * on its single-table-inheritance discriminator and resolves nothing for an
+     * override.
+     */
+    constructor(entities) {
+        this.entities = entities;
+    }
     async mapData({ id }, { loaders }) {
         const map = await loaders.batchSingle.load({
-            __entity: warehouseMap_entity.WarehouseMapEntity,
+            __entity: this.entities.warehouseMap,
             __from: { id },
         });
         return map?.mapData || null;
@@ -3682,7 +3973,7 @@ let LocationResolver = class LocationResolver {
         if (!parentId)
             return null;
         return loaders.batchSingle.load({
-            __entity: wmsModuleCore.LocationEntityClass,
+            __entity: this.entities.location,
             __from: { id: parentId },
         });
     }
@@ -3697,7 +3988,7 @@ let LocationResolver = class LocationResolver {
      */
     children({ id }, { loaders }) {
         return loaders.batchMany.load({
-            __entity: wmsModuleCore.LocationEntityClass,
+            __entity: this.entities.location,
             __from: { parentId: id },
             __conditions: (qb) => qb.orderBy('entity."key"', 'ASC'),
         });
@@ -3728,7 +4019,8 @@ tslib.__decorate([
     tslib.__metadata("design:returntype", Promise)
 ], LocationResolver.prototype, "children", null);
 LocationResolver = tslib.__decorate([
-    graphql.Resolver(() => LocationDto)
+    graphql.Resolver(() => LocationDto),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.WmsEntities])
 ], LocationResolver);
 
 let FindLocationArgs = class FindLocationArgs extends PaginationArgs {
@@ -3918,31 +4210,23 @@ UnitQuery = tslib.__decorate([
 
 let AggregatedStockResolver = class AggregatedStockResolver {
     stockService;
-    materialEntity;
-    /**
-     * `materialEntity` is bound to the `MaterialEntity` Symbol, so the DataLoader
-     * queries whichever material entity the consumer configured — the built-in
-     * `MaterialEntityClass` unless `materialEntity` was passed to
-     * `forRoot`/`forRootAsync`. Loading the built-in class outright would filter on
-     * its single-table-inheritance discriminator and resolve nothing for a custom
-     * entity.
-     */
-    constructor(stockService, materialEntity) {
+    entities;
+    constructor(stockService, entities) {
         this.stockService = stockService;
-        this.materialEntity = materialEntity;
+        this.entities = entities;
     }
     async id(stock) {
         return this.stockService.generatedAggregateKey(stock);
     }
     async material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: this.materialEntity,
+            __entity: this.entities.material,
             __from: { id: materialId },
         });
     }
     async batch({ batchId }, { loaders }) {
         const { groupId } = await loaders.batchSingle.load({
-            __entity: wmsModuleCore.BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         });
         return loaders.batchSingle.load({
@@ -3952,7 +4236,7 @@ let AggregatedStockResolver = class AggregatedStockResolver {
     }
     async location({ locationId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: wmsModuleCore.LocationEntityClass,
+            __entity: this.entities.location,
             __from: { id: locationId },
         });
     }
@@ -4004,8 +4288,8 @@ tslib.__decorate([
 ], AggregatedStockResolver.prototype, "loader", null);
 AggregatedStockResolver = tslib.__decorate([
     graphql.Resolver(() => AggregatedStockDto),
-    tslib.__param(1, common.Inject(wmsModuleCore.MaterialEntity)),
-    tslib.__metadata("design:paramtypes", [wmsModuleCore.StockService, Function])
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.StockService,
+        wmsModuleCore.WmsEntities])
 ], AggregatedStockResolver);
 
 let CreateTransferOrderItemArgs = class CreateTransferOrderItemArgs {
@@ -4330,6 +4614,17 @@ TransferOrderQuery = tslib.__decorate([
 ], TransferOrderQuery);
 
 let TransferOrderResolver = class TransferOrderResolver {
+    entities;
+    /**
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`. Loading a built-in class outright filters
+     * on its single-table-inheritance discriminator and resolves nothing for an
+     * override.
+     */
+    constructor(entities) {
+        this.entities = entities;
+    }
     items({ id }, { loaders }) {
         return loaders.batchMany.load({
             __entity: wmsModuleCore.TransferOrderItemEntityClass,
@@ -4344,7 +4639,7 @@ let TransferOrderResolver = class TransferOrderResolver {
         if (!item?.targetLocationId)
             return null;
         return locationLoader.loaders.batchSingle.load({
-            __entity: wmsModuleCore.LocationEntityClass,
+            __entity: this.entities.location,
             __from: { id: item.targetLocationId },
         });
     }
@@ -4388,23 +4683,24 @@ tslib.__decorate([
     tslib.__metadata("design:returntype", Promise)
 ], TransferOrderResolver.prototype, "targetLoader", null);
 TransferOrderResolver = tslib.__decorate([
-    graphql.Resolver(() => TransferOrderDto)
+    graphql.Resolver(() => TransferOrderDto),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.WmsEntities])
 ], TransferOrderResolver);
 let TransferOrderItemResolver = class TransferOrderItemResolver {
-    materialEntity;
+    entities;
     /**
-     * Bound to the `MaterialEntity` Symbol, so the DataLoader queries whichever
-     * material entity the consumer configured — the built-in `MaterialEntityClass`
-     * unless `materialEntity` was passed to `forRoot`/`forRootAsync`. Loading the
-     * built-in class outright would filter on its single-table-inheritance
-     * discriminator and resolve nothing for a custom entity.
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`. Loading a built-in class outright filters
+     * on its single-table-inheritance discriminator and resolves nothing for an
+     * override.
      */
-    constructor(materialEntity) {
-        this.materialEntity = materialEntity;
+    constructor(entities) {
+        this.entities = entities;
     }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: this.materialEntity,
+            __entity: this.entities.material,
             __from: { id: materialId },
         });
     }
@@ -4412,7 +4708,7 @@ let TransferOrderItemResolver = class TransferOrderItemResolver {
         if (!batchId)
             return null;
         const { groupId } = await loaders.batchSingle.load({
-            __entity: wmsModuleCore.BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         });
         return loaders.batchSingle.load({
@@ -4424,7 +4720,7 @@ let TransferOrderItemResolver = class TransferOrderItemResolver {
         if (!locationId)
             return null;
         return loaders.batchSingle.load({
-            __entity: wmsModuleCore.LocationEntityClass,
+            __entity: this.entities.location,
             __from: { id: locationId },
         });
     }
@@ -4441,7 +4737,7 @@ let TransferOrderItemResolver = class TransferOrderItemResolver {
             return null;
         return loaders.batchSingle
             .load({
-            __entity: wmsModuleCore.BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         })
             .then((batch) => batch.saleId);
@@ -4451,7 +4747,7 @@ let TransferOrderItemResolver = class TransferOrderItemResolver {
             return null;
         return loaders.batchSingle
             .load({
-            __entity: wmsModuleCore.BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         })
             .then((batch) => batch.saleSerialId);
@@ -4525,8 +4821,7 @@ tslib.__decorate([
 ], TransferOrderItemResolver.prototype, "transferredQuantity", null);
 TransferOrderItemResolver = tslib.__decorate([
     graphql.Resolver(() => TransferOrderItemDto),
-    tslib.__param(0, common.Inject(wmsModuleCore.MaterialEntity)),
-    tslib.__metadata("design:paramtypes", [Function])
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.WmsEntities])
 ], TransferOrderItemResolver);
 
 let CreateHoldInventoryOrderItemArgs = class CreateHoldInventoryOrderItemArgs {
@@ -4822,32 +5117,32 @@ BatchQuery = tslib.__decorate([
 ], BatchQuery);
 
 let ChangeLogResolver = class ChangeLogResolver {
-    materialEntity;
+    entities;
     /**
-     * Bound to the `MaterialEntity` Symbol, so the DataLoader queries whichever
-     * material entity the consumer configured — the built-in `MaterialEntityClass`
-     * unless `materialEntity` was passed to `forRoot`/`forRootAsync`. Loading the
-     * built-in class outright would filter on its single-table-inheritance
-     * discriminator and resolve nothing for a custom entity.
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`. Loading a built-in class outright filters
+     * on its single-table-inheritance discriminator and resolves nothing for an
+     * override.
      */
-    constructor(materialEntity) {
-        this.materialEntity = materialEntity;
+    constructor(entities) {
+        this.entities = entities;
     }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: this.materialEntity,
+            __entity: this.entities.material,
             __from: { id: materialId },
         });
     }
     location({ locationId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: wmsModuleCore.LocationEntityClass,
+            __entity: this.entities.location,
             __from: { id: locationId },
         });
     }
     async batch({ batchId }, { loaders }) {
         const { groupId } = await loaders.batchSingle.load({
-            __entity: wmsModuleCore.BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         });
         return loaders.batchSingle.load({
@@ -4882,8 +5177,7 @@ tslib.__decorate([
 ], ChangeLogResolver.prototype, "batch", null);
 ChangeLogResolver = tslib.__decorate([
     graphql.Resolver(() => ChangeLogDto),
-    tslib.__param(0, common.Inject(wmsModuleCore.MaterialEntity)),
-    tslib.__metadata("design:paramtypes", [Function])
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.WmsEntities])
 ], ChangeLogResolver);
 
 let ReceiveInventoryOrderResolver = class ReceiveInventoryOrderResolver {
@@ -4907,20 +5201,20 @@ ReceiveInventoryOrderResolver = tslib.__decorate([
     graphql.Resolver(() => ReceiveInventoryOrderDto)
 ], ReceiveInventoryOrderResolver);
 let ReceiveInventoryOrderItemResolver = class ReceiveInventoryOrderItemResolver {
-    materialEntity;
+    entities;
     /**
-     * Bound to the `MaterialEntity` Symbol, so the DataLoader queries whichever
-     * material entity the consumer configured — the built-in `MaterialEntityClass`
-     * unless `materialEntity` was passed to `forRoot`/`forRootAsync`. Loading the
-     * built-in class outright would filter on its single-table-inheritance
-     * discriminator and resolve nothing for a custom entity.
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`. Loading a built-in class outright filters
+     * on its single-table-inheritance discriminator and resolves nothing for an
+     * override.
      */
-    constructor(materialEntity) {
-        this.materialEntity = materialEntity;
+    constructor(entities) {
+        this.entities = entities;
     }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: this.materialEntity,
+            __entity: this.entities.material,
             __from: { id: materialId },
         });
     }
@@ -4928,7 +5222,7 @@ let ReceiveInventoryOrderItemResolver = class ReceiveInventoryOrderItemResolver
         if (!batchId)
             return null;
         const { groupId } = await loaders.batchSingle.load({
-            __entity: wmsModuleCore.BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         });
         return loaders.batchSingle.load({
@@ -4940,7 +5234,7 @@ let ReceiveInventoryOrderItemResolver = class ReceiveInventoryOrderItemResolver
         if (!locationId)
             return null;
         return loaders.batchSingle.load({
-            __entity: wmsModuleCore.LocationEntityClass,
+            __entity: this.entities.location,
             __from: { id: locationId },
         });
     }
@@ -5004,8 +5298,7 @@ tslib.__decorate([
 ], ReceiveInventoryOrderItemResolver.prototype, "receivedQuantity", null);
 ReceiveInventoryOrderItemResolver = tslib.__decorate([
     graphql.Resolver(() => ReceiveInventoryOrderItemDto),
-    tslib.__param(0, common.Inject(wmsModuleCore.MaterialEntity)),
-    tslib.__metadata("design:paramtypes", [Function])
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.WmsEntities])
 ], ReceiveInventoryOrderItemResolver);
 
 let FindAllocateInventoryOrderArgs = class FindAllocateInventoryOrderArgs extends PaginationArgs {
@@ -5342,20 +5635,20 @@ ShipInventoryOrderResolver = tslib.__decorate([
     graphql.Resolver(() => ShipInventoryOrderDto)
 ], ShipInventoryOrderResolver);
 let ShipInventoryOrderItemResolver = class ShipInventoryOrderItemResolver {
-    materialEntity;
+    entities;
     /**
-     * Bound to the `MaterialEntity` Symbol, so the DataLoader queries whichever
-     * material entity the consumer configured — the built-in `MaterialEntityClass`
-     * unless `materialEntity` was passed to `forRoot`/`forRootAsync`. Loading the
-     * built-in class outright would filter on its single-table-inheritance
-     * discriminator and resolve nothing for a custom entity.
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`. Loading a built-in class outright filters
+     * on its single-table-inheritance discriminator and resolves nothing for an
+     * override.
      */
-    constructor(materialEntity) {
-        this.materialEntity = materialEntity;
+    constructor(entities) {
+        this.entities = entities;
     }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: this.materialEntity,
+            __entity: this.entities.material,
             __from: { id: materialId },
         });
     }
@@ -5363,7 +5656,7 @@ let ShipInventoryOrderItemResolver = class ShipInventoryOrderItemResolver {
         if (!batchId)
             return null;
         const { groupId } = await loaders.batchSingle.load({
-            __entity: wmsModuleCore.BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         });
         return loaders.batchSingle.load({
@@ -5375,7 +5668,7 @@ let ShipInventoryOrderItemResolver = class ShipInventoryOrderItemResolver {
         if (!batchId)
             return null;
         const { groupId } = await loaders.batchSingle.load({
-            __entity: wmsModuleCore.BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         });
         return loaders.batchSingle
@@ -5389,7 +5682,7 @@ let ShipInventoryOrderItemResolver = class ShipInventoryOrderItemResolver {
         if (!batchId)
             return null;
         const { groupId } = await loaders.batchSingle.load({
-            __entity: wmsModuleCore.BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         });
         return loaders.batchSingle
@@ -5403,7 +5696,7 @@ let ShipInventoryOrderItemResolver = class ShipInventoryOrderItemResolver {
         if (!locationId)
             return null;
         return loaders.batchSingle.load({
-            __entity: wmsModuleCore.LocationEntityClass,
+            __entity: this.entities.location,
             __from: { id: locationId },
         });
     }
@@ -5484,20 +5777,19 @@ tslib.__decorate([
 ], ShipInventoryOrderItemResolver.prototype, "shippedQuantity", null);
 ShipInventoryOrderItemResolver = tslib.__decorate([
     graphql.Resolver(() => ShipInventoryOrderItemDto),
-    tslib.__param(0, common.Inject(wmsModuleCore.MaterialEntity)),
-    tslib.__metadata("design:paramtypes", [Function])
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.WmsEntities])
 ], ShipInventoryOrderItemResolver);
 let ShipInventoryOrderReferenceResolver = class ShipInventoryOrderReferenceResolver {
-    materialEntity;
+    entities;
     /**
-     * Bound to the `MaterialEntity` Symbol, so the DataLoader queries whichever
-     * material entity the consumer configured — the built-in `MaterialEntityClass`
-     * unless `materialEntity` was passed to `forRoot`/`forRootAsync`. Loading the
-     * built-in class outright would filter on its single-table-inheritance
-     * discriminator and resolve nothing for a custom entity.
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`. Loading a built-in class outright filters
+     * on its single-table-inheritance discriminator and resolves nothing for an
+     * override.
      */
-    constructor(materialEntity) {
-        this.materialEntity = materialEntity;
+    constructor(entities) {
+        this.entities = entities;
     }
     async shippedQuantity({ orderId, serialId }, { loaders }) {
         const items = await loaders.batchMany.load({
@@ -5513,7 +5805,7 @@ let ShipInventoryOrderReferenceResolver = class ShipInventoryOrderReferenceResol
     }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: this.materialEntity,
+            __entity: this.entities.material,
             __from: { id: materialId },
         });
     }
@@ -5521,7 +5813,7 @@ let ShipInventoryOrderReferenceResolver = class ShipInventoryOrderReferenceResol
         if (!batchId)
             return null;
         const { groupId } = await loaders.batchSingle.load({
-            __entity: wmsModuleCore.BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         });
         return loaders.batchSingle.load({
@@ -5570,8 +5862,7 @@ tslib.__decorate([
 ], ShipInventoryOrderReferenceResolver.prototype, "items", null);
 ShipInventoryOrderReferenceResolver = tslib.__decorate([
     graphql.Resolver(() => ShipInventoryOrderReferenceDto),
-    tslib.__param(0, common.Inject(wmsModuleCore.MaterialEntity)),
-    tslib.__metadata("design:paramtypes", [Function])
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.WmsEntities])
 ], ShipInventoryOrderReferenceResolver);
 
 let FindSaleOrderArgs = class FindSaleOrderArgs extends PaginationArgs {
@@ -6626,11 +6917,22 @@ WarehouseMapDataQuery = tslib.__decorate([
 ], WarehouseMapDataQuery);
 
 let MapRangeUnionResolver = class MapRangeUnionResolver {
+    entities;
+    /**
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`. Loading a built-in class outright filters
+     * on its single-table-inheritance discriminator and resolves nothing for an
+     * override.
+     */
+    constructor(entities) {
+        this.entities = entities;
+    }
     location({ id }, { loaders }) {
         if (!id)
             return null;
         return loaders.batchSingle.load({
-            __entity: wmsModuleCore.LocationEntityClass,
+            __entity: this.entities.location,
             __from: { key: id },
         });
     }
@@ -6644,9 +6946,498 @@ tslib.__decorate([
     tslib.__metadata("design:returntype", void 0)
 ], MapRangeUnionResolver.prototype, "location", null);
 MapRangeUnionResolver = tslib.__decorate([
-    graphql.Resolver(() => MapRangeDto)
+    graphql.Resolver(() => MapRangeDto),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.WmsEntities])
 ], MapRangeUnionResolver);
 
+let FindInventoryCountOrderArgs = class FindInventoryCountOrderArgs extends PaginationArgs {
+    name;
+    statuses;
+    createdBy;
+    /** Inclusive lower bound on `countDate`, `YYYY-MM-DD`. */
+    countDateFrom;
+    /** Inclusive upper bound on `countDate`, `YYYY-MM-DD`. */
+    countDateTo;
+    /**
+     * Matches against the expanded scope, not the roots the user picked, so
+     * filtering by a shelf finds the count that covers its whole aisle.
+     */
+    locationIds;
+};
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], FindInventoryCountOrderArgs.prototype, "name", void 0);
+tslib.__decorate([
+    graphql.Field(() => [wmsModuleCore.InventoryCountStatus], { nullable: true }),
+    tslib.__metadata("design:type", Array)
+], FindInventoryCountOrderArgs.prototype, "statuses", void 0);
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], FindInventoryCountOrderArgs.prototype, "createdBy", void 0);
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], FindInventoryCountOrderArgs.prototype, "countDateFrom", void 0);
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], FindInventoryCountOrderArgs.prototype, "countDateTo", void 0);
+tslib.__decorate([
+    graphql.Field(() => [graphql.ID], { nullable: true }),
+    tslib.__metadata("design:type", Array)
+], FindInventoryCountOrderArgs.prototype, "locationIds", void 0);
+FindInventoryCountOrderArgs = tslib.__decorate([
+    graphql.ArgsType()
+], FindInventoryCountOrderArgs);
+let CreateInventoryCountOrderArgs = class CreateInventoryCountOrderArgs {
+    name;
+    countDate;
+    /** Root locations; every descendant is pulled into scope automatically. */
+    locationIds;
+};
+tslib.__decorate([
+    graphql.Field(() => String),
+    tslib.__metadata("design:type", String)
+], CreateInventoryCountOrderArgs.prototype, "name", void 0);
+tslib.__decorate([
+    graphql.Field(() => String),
+    tslib.__metadata("design:type", String)
+], CreateInventoryCountOrderArgs.prototype, "countDate", void 0);
+tslib.__decorate([
+    graphql.Field(() => [graphql.ID]),
+    tslib.__metadata("design:type", Array)
+], CreateInventoryCountOrderArgs.prototype, "locationIds", void 0);
+CreateInventoryCountOrderArgs = tslib.__decorate([
+    graphql.ArgsType()
+], CreateInventoryCountOrderArgs);
+let UpdateInventoryCountOrderArgs = class UpdateInventoryCountOrderArgs {
+    id;
+    name;
+    countDate;
+    locationIds;
+};
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], UpdateInventoryCountOrderArgs.prototype, "id", void 0);
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], UpdateInventoryCountOrderArgs.prototype, "name", void 0);
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], UpdateInventoryCountOrderArgs.prototype, "countDate", void 0);
+tslib.__decorate([
+    graphql.Field(() => [graphql.ID], { nullable: true }),
+    tslib.__metadata("design:type", Array)
+], UpdateInventoryCountOrderArgs.prototype, "locationIds", void 0);
+UpdateInventoryCountOrderArgs = tslib.__decorate([
+    graphql.ArgsType()
+], UpdateInventoryCountOrderArgs);
+let CountInventoryItemInput = class CountInventoryItemInput {
+    itemId;
+    /** `null` clears the entry, putting the line back to "not counted". */
+    countedQuantity;
+    unitId;
+};
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], CountInventoryItemInput.prototype, "itemId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.Float, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], CountInventoryItemInput.prototype, "countedQuantity", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], CountInventoryItemInput.prototype, "unitId", void 0);
+CountInventoryItemInput = tslib.__decorate([
+    graphql.InputType()
+], CountInventoryItemInput);
+let CountInventoryArgs = class CountInventoryArgs {
+    id;
+    items;
+};
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], CountInventoryArgs.prototype, "id", void 0);
+tslib.__decorate([
+    graphql.Field(() => [CountInventoryItemInput]),
+    tslib.__metadata("design:type", Array)
+], CountInventoryArgs.prototype, "items", void 0);
+CountInventoryArgs = tslib.__decorate([
+    graphql.ArgsType()
+], CountInventoryArgs);
+let AddInventoryCountItemArgs = class AddInventoryCountItemArgs {
+    id;
+    materialId;
+    /** An existing batch key, or a new one — the batch is created on demand. */
+    batchKey;
+    locationId;
+    loaderId;
+    countedQuantity;
+    unitId;
+};
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], AddInventoryCountItemArgs.prototype, "id", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], AddInventoryCountItemArgs.prototype, "materialId", void 0);
+tslib.__decorate([
+    graphql.Field(() => String),
+    tslib.__metadata("design:type", String)
+], AddInventoryCountItemArgs.prototype, "batchKey", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], AddInventoryCountItemArgs.prototype, "locationId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], AddInventoryCountItemArgs.prototype, "loaderId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.Float),
+    tslib.__metadata("design:type", Number)
+], AddInventoryCountItemArgs.prototype, "countedQuantity", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], AddInventoryCountItemArgs.prototype, "unitId", void 0);
+AddInventoryCountItemArgs = tslib.__decorate([
+    graphql.ArgsType()
+], AddInventoryCountItemArgs);
+let RemoveInventoryCountItemArgs = class RemoveInventoryCountItemArgs {
+    id;
+    itemId;
+};
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], RemoveInventoryCountItemArgs.prototype, "id", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], RemoveInventoryCountItemArgs.prototype, "itemId", void 0);
+RemoveInventoryCountItemArgs = tslib.__decorate([
+    graphql.ArgsType()
+], RemoveInventoryCountItemArgs);
+let InventoryCountOrderIdArgs = class InventoryCountOrderIdArgs {
+    id;
+};
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], InventoryCountOrderIdArgs.prototype, "id", void 0);
+InventoryCountOrderIdArgs = tslib.__decorate([
+    graphql.ArgsType()
+], InventoryCountOrderIdArgs);
+
+let InventoryCountOrderQuery = class InventoryCountOrderQuery {
+    inventoryCountOrderService;
+    constructor(inventoryCountOrderService) {
+        this.inventoryCountOrderService = inventoryCountOrderService;
+    }
+    async inventoryCountOrders(args) {
+        const [items, total] = await this.inventoryCountOrderService.findMany(args);
+        return { items, total };
+    }
+    async inventoryCountOrder({ id }) {
+        return this.inventoryCountOrderService.findOne(id);
+    }
+};
+tslib.__decorate([
+    graphql.Query(() => InventoryCountOrders),
+    WmsOperation({ resource: 'inventory-count-order', action: 'read' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [FindInventoryCountOrderArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderQuery.prototype, "inventoryCountOrders", null);
+tslib.__decorate([
+    graphql.Query(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'read' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [InventoryCountOrderIdArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderQuery.prototype, "inventoryCountOrder", null);
+InventoryCountOrderQuery = tslib.__decorate([
+    common.Injectable(),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.InventoryCountOrderService])
+], InventoryCountOrderQuery);
+
+let InventoryCountOrderMutation = class InventoryCountOrderMutation {
+    inventoryCountOrderService;
+    constructor(inventoryCountOrderService) {
+        this.inventoryCountOrderService = inventoryCountOrderService;
+    }
+    async createInventoryCountOrder(args) {
+        return this.inventoryCountOrderService.create(args);
+    }
+    async updateInventoryCountOrder({ id, ...input }) {
+        return this.inventoryCountOrderService.update(id, input);
+    }
+    async startInventoryCount({ id }) {
+        return this.inventoryCountOrderService.start(id);
+    }
+    /** "暫存結果" — record what was counted without touching stock. */
+    async countInventory({ id, items }) {
+        return this.inventoryCountOrderService.count(id, items.map((item) => ({
+            itemId: item.itemId,
+            countedQuantity: item.countedQuantity ?? null,
+            unitId: item.unitId,
+        })));
+    }
+    async addInventoryCountItem({ id, ...input }) {
+        return this.inventoryCountOrderService.addItem(id, input);
+    }
+    async removeInventoryCountItem({ id, itemId }) {
+        return this.inventoryCountOrderService.removeItem(id, itemId);
+    }
+    /** "清空重填" — discard the counting, keep the lock and the status. */
+    async resetInventoryCount({ id }) {
+        return this.inventoryCountOrderService.reset(id);
+    }
+    async cancelInventoryCount({ id }) {
+        return this.inventoryCountOrderService.cancel(id);
+    }
+    /** "執行盤差" — the only mutation here that changes stock. */
+    async settleInventoryCount({ id }) {
+        return this.inventoryCountOrderService.settle(id);
+    }
+};
+tslib.__decorate([
+    graphql.Mutation(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'create' }),
+    WmsMutationEvent({ event: 'inventory-count-order.created' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [CreateInventoryCountOrderArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "createInventoryCountOrder", null);
+tslib.__decorate([
+    graphql.Mutation(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'update' }),
+    WmsMutationEvent({ event: 'inventory-count-order.updated' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [UpdateInventoryCountOrderArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "updateInventoryCountOrder", null);
+tslib.__decorate([
+    graphql.Mutation(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'start' }),
+    WmsMutationEvent({ event: 'inventory-count-order.started' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [InventoryCountOrderIdArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "startInventoryCount", null);
+tslib.__decorate([
+    graphql.Mutation(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'count' }),
+    WmsMutationEvent({ event: 'inventory-count-order.counted' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [CountInventoryArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "countInventory", null);
+tslib.__decorate([
+    graphql.Mutation(() => InventoryCountOrderItemDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'add-item' }),
+    WmsMutationEvent({ event: 'inventory-count-order.updated' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [AddInventoryCountItemArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "addInventoryCountItem", null);
+tslib.__decorate([
+    graphql.Mutation(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'remove-item' }),
+    WmsMutationEvent({ event: 'inventory-count-order.updated' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [RemoveInventoryCountItemArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "removeInventoryCountItem", null);
+tslib.__decorate([
+    graphql.Mutation(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'reset' }),
+    WmsMutationEvent({ event: 'inventory-count-order.reset' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [InventoryCountOrderIdArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "resetInventoryCount", null);
+tslib.__decorate([
+    graphql.Mutation(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'cancel' }),
+    WmsMutationEvent({ event: 'inventory-count-order.cancelled' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [InventoryCountOrderIdArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "cancelInventoryCount", null);
+tslib.__decorate([
+    graphql.Mutation(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'settle' }),
+    WmsMutationEvent({ event: 'inventory-count-order.settled' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [InventoryCountOrderIdArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "settleInventoryCount", null);
+InventoryCountOrderMutation = tslib.__decorate([
+    common.Injectable(),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.InventoryCountOrderService])
+], InventoryCountOrderMutation);
+
+let InventoryCountOrderResolver = class InventoryCountOrderResolver {
+    entities;
+    constructor(entities) {
+        this.entities = entities;
+    }
+    items({ id }, { loaders }) {
+        return loaders.batchMany.load({
+            __entity: wmsModuleCore.InventoryCountOrderItemEntityClass,
+            __from: { orderId: id },
+        });
+    }
+    /**
+     * The locations the user picked.
+     *
+     * Only the roots: the scope table also holds every descendant the backend
+     * expanded into, and listing a whole aisle's shelves as chips would bury the
+     * one thing the operator actually chose. The expansion still exists in the
+     * database — it is what the lock reads — it just is not this field.
+     */
+    async locations({ id }, { loaders }) {
+        const scope = (await loaders.batchMany.load({
+            __entity: wmsModuleCore.InventoryCountOrderLocationEntityClass,
+            __from: { orderId: id },
+        }));
+        // The join rows carry `locationId`, not a loaded `location` relation, so
+        // each one has to go back through the location DataLoader. Returning
+        // `row.location` directly yields `undefined`, and the non-nullable list then
+        // fails the whole query with "Cannot return null for non-nullable field".
+        return Promise.all(scope
+            .filter(({ isRoot }) => isRoot)
+            .map(({ locationId }) => loaders.batchSingle.load({
+            __entity: this.entities.location,
+            __from: { id: locationId },
+        })));
+    }
+};
+tslib.__decorate([
+    graphql.ResolveField(() => [InventoryCountOrderItemDto]),
+    tslib.__param(0, graphql.Parent()),
+    tslib.__param(1, graphql.Context()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [InventoryCountOrderDto, Object]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderResolver.prototype, "items", null);
+tslib.__decorate([
+    graphql.ResolveField(() => [LocationDto]),
+    tslib.__param(0, graphql.Parent()),
+    tslib.__param(1, graphql.Context()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [InventoryCountOrderDto, Object]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderResolver.prototype, "locations", null);
+InventoryCountOrderResolver = tslib.__decorate([
+    graphql.Resolver(() => InventoryCountOrderDto),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.WmsEntities])
+], InventoryCountOrderResolver);
+let InventoryCountOrderItemResolver = class InventoryCountOrderItemResolver {
+    entities;
+    /**
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`.
+     */
+    constructor(entities) {
+        this.entities = entities;
+    }
+    material({ materialId }, { loaders }) {
+        return loaders.batchSingle.load({
+            __entity: this.entities.material,
+            __from: { id: materialId },
+        });
+    }
+    async batch({ batchId }, { loaders }) {
+        const { groupId } = await loaders.batchSingle.load({
+            __entity: this.entities.batch,
+            __from: { id: batchId },
+        });
+        return loaders.batchSingle.load({
+            __entity: wmsModuleCore.BatchGroupEntityClass,
+            __from: { id: groupId },
+        });
+    }
+    location({ locationId }, { loaders }) {
+        if (!locationId) {
+            return null;
+        }
+        return loaders.batchSingle.load({
+            __entity: this.entities.location,
+            __from: { id: locationId },
+        });
+    }
+    loader({ loaderId }, { loaders }) {
+        if (!loaderId) {
+            return null;
+        }
+        return loaders.batchSingle.load({
+            __entity: wmsModuleCore.LoadersEntityClass,
+            __from: { id: loaderId },
+        });
+    }
+};
+tslib.__decorate([
+    graphql.ResolveField(() => MaterialDto),
+    tslib.__param(0, graphql.Parent()),
+    tslib.__param(1, graphql.Context()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [InventoryCountOrderItemDto, Object]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderItemResolver.prototype, "material", null);
+tslib.__decorate([
+    graphql.ResolveField(() => BatchDto),
+    tslib.__param(0, graphql.Parent()),
+    tslib.__param(1, graphql.Context()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [InventoryCountOrderItemDto, Object]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderItemResolver.prototype, "batch", null);
+tslib.__decorate([
+    graphql.ResolveField(() => LocationDto, { nullable: true }),
+    tslib.__param(0, graphql.Parent()),
+    tslib.__param(1, graphql.Context()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [InventoryCountOrderItemDto, Object]),
+    tslib.__metadata("design:returntype", Object)
+], InventoryCountOrderItemResolver.prototype, "location", null);
+tslib.__decorate([
+    graphql.ResolveField(() => LoaderDto, { nullable: true }),
+    tslib.__param(0, graphql.Parent()),
+    tslib.__param(1, graphql.Context()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [InventoryCountOrderItemDto, Object]),
+    tslib.__metadata("design:returntype", Object)
+], InventoryCountOrderItemResolver.prototype, "loader", null);
+InventoryCountOrderItemResolver = tslib.__decorate([
+    graphql.Resolver(() => InventoryCountOrderItemDto),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.WmsEntities])
+], InventoryCountOrderItemResolver);
+
 var WmsModuleGraphqlModule_1;
 const exportDependencies = [
     UnitQuery,
@@ -6701,10 +7492,23 @@ const exportDependencies = [
     QualityInspectionOrderMutation,
     WarehouseMapDataQuery,
     MapRangeUnionResolver,
+    InventoryCountOrderQuery,
+    InventoryCountOrderMutation,
+    InventoryCountOrderResolver,
+    InventoryCountOrderItemResolver,
 ];
 exports.WmsModuleGraphqlModule = WmsModuleGraphqlModule_1 = class WmsModuleGraphqlModule {
     static forRootAsync(options) {
-        const { authChecker, beforeHooks, afterListeners, actorExtractor, eventEmitterBridge, ...coreOptions } = options;
+        const { authChecker, beforeHooks, afterListeners, actorExtractor, eventEmitterBridge, enabledOperations, disabledOperations, disabledFields, ...coreOptions } = options;
+        // Must run before `GraphQLModule` builds the schema. `forRootAsync` is
+        // called while `AppModule` is still being defined, so this is the earliest
+        // point at which the deployment's switches are known — and it is early
+        // enough: the schema is not built until the app bootstraps.
+        pruneDisabledOperations(exportDependencies, {
+            enabledOperations,
+            disabledOperations,
+            disabledFields,
+        });
         // coreOptions still carries `enrichStockEvents`, forwarded to the core module.
         const coreModule = wmsModuleCore.WmsModuleCoreModule.forRootAsync(coreOptions);
         const authOptions = { authChecker };
@@ -6739,6 +7543,10 @@ exports.WmsModuleGraphqlModule = WmsModuleGraphqlModule_1 = tslib.__decorate([
     })
 ], exports.WmsModuleGraphqlModule);
 
+Object.defineProperty(exports, "WMS_OPERATION_NAMES", {
+    enumerable: true,
+    get: function () { return wmsModuleCore.WMS_OPERATION_NAMES; }
+});
 exports.HOST_SKIP_METADATA_KEY = HOST_SKIP_METADATA_KEY;
 exports.WMS_AUTH_OPTIONS = WMS_AUTH_OPTIONS;
 exports.WMS_MUTATION_EVENT_METADATA = WMS_MUTATION_EVENT_METADATA;
@@ -6746,3 +7554,4 @@ exports.WMS_OPERATION_METADATA = WMS_OPERATION_METADATA;
 exports.WmsMutationEvent = WmsMutationEvent;
 exports.WmsOperation = WmsOperation;
 exports.createWmsLoaders = createWmsLoaders;
+exports.pruneDisabledOperations = pruneDisabledOperations;