@openlup/platform 0.16.0 → 0.18.0

package/dist/catalog/draftHandler.d.ts

@@ -0,0 +1,25 @@
+import { type CatalogDraftApplyResult, type CatalogDraftPage, type CatalogDraftRecord, type CatalogDraftRefusal } from "./draftSchemas.js";
+import { type CatalogDraftOperator, type CatalogDraftStorePort } from "./draftPorts.js";
+import type { CatalogDraftIssue, CatalogProductTypeRegistry } from "./productTypeSchemas.js";
+import { type CatalogDraftReadiness } from "./draftValidation.js";
+export interface CatalogDraftHandlerDeps<Context> {
+    store: CatalogDraftStorePort;
+    registry: CatalogProductTypeRegistry;
+    authorizeOperator: (context: Context) => Promise<CatalogDraftOperator | null>;
+}
+export type CatalogDraftCommandResult = CatalogDraftApplyResult & {
+    issues?: readonly CatalogDraftIssue[];
+    readiness?: CatalogDraftReadiness;
+};
+/** Dark use case: mounting requires a verified operator authorizer at composition. */
+export declare function createCatalogDraftHandler<Context>(deps: CatalogDraftHandlerDeps<Context>): {
+    execute(input: unknown, context: Context): Promise<CatalogDraftCommandResult>;
+    get(input: unknown, context: Context): Promise<{
+        outcome: "found";
+        record: CatalogDraftRecord | null;
+    } | CatalogDraftRefusal>;
+    list(input: unknown, context: Context): Promise<{
+        outcome: "listed";
+        page: CatalogDraftPage;
+    } | CatalogDraftRefusal>;
+};

package/dist/catalog/draftHandler.js

@@ -0,0 +1,118 @@
+import { createHash } from "node:crypto";
+import { canonicalCatalogDraftJson, catalogDraftApplyResultSchema, catalogDraftCommandSchema, catalogDraftGetQuerySchema, catalogDraftListQuerySchema, catalogDraftPageSchema, catalogDraftRecordSchema, catalogDraftRefusalSchema, } from "./draftSchemas.js";
+import { CatalogDraftStoreError, } from "./draftPorts.js";
+import { validateCatalogDraft } from "./draftValidation.js";
+const unavailable = () => ({ outcome: "dependency_unavailable", reason: "draft_dependency_unavailable" });
+const invalid = () => ({ outcome: "validation_issue", reason: "draft_input_invalid" });
+function failure(error) {
+    if (error instanceof CatalogDraftStoreError) {
+        const parsed = catalogDraftRefusalSchema.safeParse(error.refusal);
+        if (parsed.success)
+            return parsed.data;
+    }
+    return unavailable();
+}
+/** Dark use case: mounting requires a verified operator authorizer at composition. */
+export function createCatalogDraftHandler(deps) {
+    async function actor(context) {
+        try {
+            const operator = await deps.authorizeOperator(context);
+            if (!operator || !/^[^\s].{0,239}$/u.test(operator.actorId) || operator.actorId.trim() !== operator.actorId) {
+                return { outcome: "unauthorized", reason: "draft_operator_required" };
+            }
+            return operator;
+        }
+        catch {
+            return unavailable();
+        }
+    }
+    return {
+        async execute(input, context) {
+            const operator = await actor(context);
+            if ("outcome" in operator)
+                return operator;
+            let canonicalCommand;
+            try {
+                canonicalCommand = canonicalCatalogDraftJson(input);
+            }
+            catch {
+                return invalid();
+            }
+            const parsed = catalogDraftCommandSchema.safeParse(JSON.parse(canonicalCommand));
+            if (!parsed.success)
+                return invalid();
+            const command = parsed.data;
+            const fingerprint = createHash("sha256").update(canonicalCommand).digest("hex");
+            try {
+                // Read receipts first: changed registry, moved head or abandonment cannot erase a committed command.
+                const original = await deps.store.get({ draftId: command.draftId, commandKey: command.commandKey }, operator.actorId);
+                if (original !== null) {
+                    const record = catalogDraftRecordSchema.parse(original);
+                    if (record.draftId !== command.draftId || record.commandKey !== command.commandKey)
+                        return unavailable();
+                    if (record.actorId !== operator.actorId)
+                        return { outcome: "unauthorized", reason: "draft_command_actor_mismatch" };
+                    if (record.fingerprint !== fingerprint)
+                        return { outcome: "conflict", reason: "draft_command_key_reused" };
+                    return { outcome: "replayed", record };
+                }
+                let readiness;
+                if (command.payload) {
+                    const validation = validateCatalogDraft(command.payload, deps.registry);
+                    if (!validation.valid)
+                        return { outcome: "validation_issue", reason: "draft_payload_invalid", issues: validation.issues };
+                    readiness = validation.readiness;
+                }
+                const result = catalogDraftApplyResultSchema.parse(await deps.store.apply({ canonicalCommand, fingerprint, actorId: operator.actorId }));
+                if (result.outcome === "committed" || result.outcome === "replayed") {
+                    if (result.record.draftId !== command.draftId || result.record.commandKey !== command.commandKey
+                        || result.record.fingerprint !== fingerprint || result.record.actorId !== operator.actorId)
+                        return unavailable();
+                    return { ...result, ...(readiness ? { readiness } : {}) };
+                }
+                return result;
+            }
+            catch (error) {
+                return failure(error);
+            }
+        },
+        async get(input, context) {
+            const operator = await actor(context);
+            if ("outcome" in operator)
+                return operator;
+            const parsed = catalogDraftGetQuerySchema.safeParse(input);
+            if (!parsed.success)
+                return invalid();
+            try {
+                const value = await deps.store.get(parsed.data, operator.actorId);
+                const record = value === null ? null : catalogDraftRecordSchema.parse(value);
+                if (record && (record.draftId !== parsed.data.draftId
+                    || (parsed.data.revision !== undefined && record.revision !== parsed.data.revision)
+                    || (parsed.data.commandKey !== undefined && record.commandKey !== parsed.data.commandKey)))
+                    return unavailable();
+                return { outcome: "found", record };
+            }
+            catch (error) {
+                return failure(error);
+            }
+        },
+        async list(input, context) {
+            const operator = await actor(context);
+            if ("outcome" in operator)
+                return operator;
+            const parsed = catalogDraftListQuerySchema.safeParse(input);
+            if (!parsed.success)
+                return invalid();
+            try {
+                const page = catalogDraftPageSchema.parse(await deps.store.list(parsed.data, operator.actorId));
+                if (page.items.length > parsed.data.limit || (parsed.data.afterDraftId
+                    && page.items.some(({ draftId }) => draftId <= parsed.data.afterDraftId)))
+                    return unavailable();
+                return { outcome: "listed", page };
+            }
+            catch (error) {
+                return failure(error);
+            }
+        },
+    };
+}

package/dist/catalog/draftPorts.d.ts

@@ -0,0 +1,18 @@
+import type { CatalogDraftApplyResult, CatalogDraftGetQuery, CatalogDraftListQuery, CatalogDraftPage, CatalogDraftRecord, CatalogDraftRefusal } from "./draftSchemas.js";
+/** Portable adapters accept this actor only after the injected operator authorizer succeeds. */
+export interface CatalogDraftOperator {
+    actorId: string;
+}
+export interface CatalogDraftStorePort {
+    apply(input: {
+        canonicalCommand: string;
+        fingerprint: string;
+        actorId: string;
+    }): Promise<CatalogDraftApplyResult>;
+    get(query: CatalogDraftGetQuery, actorId: string): Promise<CatalogDraftRecord | null>;
+    list(query: CatalogDraftListQuery, actorId: string): Promise<CatalogDraftPage>;
+}
+export declare class CatalogDraftStoreError extends Error {
+    readonly refusal: CatalogDraftRefusal;
+    constructor(refusal: CatalogDraftRefusal);
+}

package/dist/catalog/draftPorts.js

@@ -0,0 +1,8 @@
+export class CatalogDraftStoreError extends Error {
+    refusal;
+    constructor(refusal) {
+        super(refusal.reason);
+        this.refusal = refusal;
+        this.name = "CatalogDraftStoreError";
+    }
+}

package/dist/catalog/draftSchemas.d.ts

@@ -0,0 +1,423 @@
+import { z } from "./validation.js";
+export { CATALOG_DRAFT_MAX_BYTES, CATALOG_DRAFT_MAX_PAGE, canonicalCatalogDraftJson } from "./contracts/draft.js";
+export type { CatalogDraftPayload, CatalogDraftCommand, CatalogDraftRecord, CatalogDraftSummary, CatalogDraftPage, CatalogDraftRefusal, CatalogDraftApplyResult, CatalogDraftGetQuery, CatalogDraftListQuery } from "./contracts/draft.js";
+export declare const catalogDraftPayloadSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    product: z.ZodObject<{
+        id: z.ZodGUID;
+        type: z.ZodObject<{
+            key: z.ZodString;
+            version: z.ZodNumber;
+        }, z.core.$strict>;
+        slug: z.ZodOptional<z.ZodString>;
+        primarySkuId: z.ZodOptional<z.ZodGUID>;
+        dimensions: z.ZodArray<z.ZodString>;
+        sharedContent: z.ZodOptional<z.ZodUnknown & z.ZodType<{} | null, unknown, z.core.$ZodTypeInternals<{} | null, unknown>>>;
+        documentRevision: z.ZodOptional<z.ZodObject<{
+            id: z.ZodGUID;
+            productId: z.ZodGUID;
+            revisionNo: z.ZodNumber;
+            schemaId: z.ZodString;
+            documentRef: z.ZodString;
+            sourceRef: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    skus: z.ZodArray<z.ZodObject<{
+        id: z.ZodGUID;
+        productId: z.ZodGUID;
+        code: z.ZodOptional<z.ZodString>;
+        options: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"choice">;
+            value: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"quantity">;
+            value: z.ZodObject<{
+                dimension: z.ZodEnum<{
+                    count: "count";
+                    mass: "mass";
+                    volume: "volume";
+                }>;
+                unscaled: z.ZodString;
+                scale: z.ZodNumber;
+                unit: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"boolean">;
+            value: z.ZodBoolean;
+        }, z.core.$strict>], "kind">>;
+        netContent: z.ZodOptional<z.ZodObject<{
+            dimension: z.ZodEnum<{
+                count: "count";
+                mass: "mass";
+                volume: "volume";
+            }>;
+            unscaled: z.ZodString;
+            scale: z.ZodNumber;
+            unit: z.ZodString;
+        }, z.core.$strict>>;
+        identifiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            scheme: z.ZodString;
+            issuer: z.ZodString;
+            value: z.ZodString;
+            packagingLevel: z.ZodEnum<{
+                unit: "unit";
+                case: "case";
+            }>;
+            quantity: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>;
+        assetRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        grossMass: z.ZodOptional<z.ZodObject<{
+            dimension: z.ZodEnum<{
+                count: "count";
+                mass: "mass";
+                volume: "volume";
+            }>;
+            unscaled: z.ZodString;
+            scale: z.ZodNumber;
+            unit: z.ZodString;
+        }, z.core.$strict>>;
+        priceRef: z.ZodOptional<z.ZodString>;
+        logisticsRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const catalogDraftCommandSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    action: z.ZodEnum<{
+        create: "create";
+        revise: "revise";
+        abandon: "abandon";
+    }>;
+    draftId: z.ZodGUID;
+    commandKey: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    payload: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        product: z.ZodObject<{
+            id: z.ZodGUID;
+            type: z.ZodObject<{
+                key: z.ZodString;
+                version: z.ZodNumber;
+            }, z.core.$strict>;
+            slug: z.ZodOptional<z.ZodString>;
+            primarySkuId: z.ZodOptional<z.ZodGUID>;
+            dimensions: z.ZodArray<z.ZodString>;
+            sharedContent: z.ZodOptional<z.ZodUnknown & z.ZodType<{} | null, unknown, z.core.$ZodTypeInternals<{} | null, unknown>>>;
+            documentRevision: z.ZodOptional<z.ZodObject<{
+                id: z.ZodGUID;
+                productId: z.ZodGUID;
+                revisionNo: z.ZodNumber;
+                schemaId: z.ZodString;
+                documentRef: z.ZodString;
+                sourceRef: z.ZodString;
+                digest: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        skus: z.ZodArray<z.ZodObject<{
+            id: z.ZodGUID;
+            productId: z.ZodGUID;
+            code: z.ZodOptional<z.ZodString>;
+            options: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"choice">;
+                value: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"quantity">;
+                value: z.ZodObject<{
+                    dimension: z.ZodEnum<{
+                        count: "count";
+                        mass: "mass";
+                        volume: "volume";
+                    }>;
+                    unscaled: z.ZodString;
+                    scale: z.ZodNumber;
+                    unit: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"boolean">;
+                value: z.ZodBoolean;
+            }, z.core.$strict>], "kind">>;
+            netContent: z.ZodOptional<z.ZodObject<{
+                dimension: z.ZodEnum<{
+                    count: "count";
+                    mass: "mass";
+                    volume: "volume";
+                }>;
+                unscaled: z.ZodString;
+                scale: z.ZodNumber;
+                unit: z.ZodString;
+            }, z.core.$strict>>;
+            identifiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                scheme: z.ZodString;
+                issuer: z.ZodString;
+                value: z.ZodString;
+                packagingLevel: z.ZodEnum<{
+                    unit: "unit";
+                    case: "case";
+                }>;
+                quantity: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>>;
+            assetRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            grossMass: z.ZodOptional<z.ZodObject<{
+                dimension: z.ZodEnum<{
+                    count: "count";
+                    mass: "mass";
+                    volume: "volume";
+                }>;
+                unscaled: z.ZodString;
+                scale: z.ZodNumber;
+                unit: z.ZodString;
+            }, z.core.$strict>>;
+            priceRef: z.ZodOptional<z.ZodString>;
+            logisticsRef: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const catalogDraftGetQuerySchema: z.ZodObject<{
+    draftId: z.ZodGUID;
+    revision: z.ZodOptional<z.ZodNumber>;
+    commandKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const catalogDraftListQuerySchema: z.ZodObject<{
+    afterDraftId: z.ZodOptional<z.ZodGUID>;
+    limit: z.ZodNumber;
+}, z.core.$strict>;
+export declare const catalogDraftSummarySchema: z.ZodObject<{
+    draftId: z.ZodGUID;
+    productId: z.ZodGUID;
+    revision: z.ZodNumber;
+    status: z.ZodEnum<{
+        open: "open";
+        abandoned: "abandoned";
+    }>;
+    commandKey: z.ZodString;
+    fingerprint: z.ZodString;
+    actorId: z.ZodString;
+    createdAt: z.ZodString;
+}, z.core.$strict>;
+export declare const catalogDraftRecordSchema: z.ZodObject<{
+    draftId: z.ZodGUID;
+    productId: z.ZodGUID;
+    revision: z.ZodNumber;
+    status: z.ZodEnum<{
+        open: "open";
+        abandoned: "abandoned";
+    }>;
+    commandKey: z.ZodString;
+    fingerprint: z.ZodString;
+    actorId: z.ZodString;
+    createdAt: z.ZodString;
+    payload: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        product: z.ZodObject<{
+            id: z.ZodGUID;
+            type: z.ZodObject<{
+                key: z.ZodString;
+                version: z.ZodNumber;
+            }, z.core.$strict>;
+            slug: z.ZodOptional<z.ZodString>;
+            primarySkuId: z.ZodOptional<z.ZodGUID>;
+            dimensions: z.ZodArray<z.ZodString>;
+            sharedContent: z.ZodOptional<z.ZodUnknown & z.ZodType<{} | null, unknown, z.core.$ZodTypeInternals<{} | null, unknown>>>;
+            documentRevision: z.ZodOptional<z.ZodObject<{
+                id: z.ZodGUID;
+                productId: z.ZodGUID;
+                revisionNo: z.ZodNumber;
+                schemaId: z.ZodString;
+                documentRef: z.ZodString;
+                sourceRef: z.ZodString;
+                digest: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        skus: z.ZodArray<z.ZodObject<{
+            id: z.ZodGUID;
+            productId: z.ZodGUID;
+            code: z.ZodOptional<z.ZodString>;
+            options: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"choice">;
+                value: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"quantity">;
+                value: z.ZodObject<{
+                    dimension: z.ZodEnum<{
+                        count: "count";
+                        mass: "mass";
+                        volume: "volume";
+                    }>;
+                    unscaled: z.ZodString;
+                    scale: z.ZodNumber;
+                    unit: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"boolean">;
+                value: z.ZodBoolean;
+            }, z.core.$strict>], "kind">>;
+            netContent: z.ZodOptional<z.ZodObject<{
+                dimension: z.ZodEnum<{
+                    count: "count";
+                    mass: "mass";
+                    volume: "volume";
+                }>;
+                unscaled: z.ZodString;
+                scale: z.ZodNumber;
+                unit: z.ZodString;
+            }, z.core.$strict>>;
+            identifiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                scheme: z.ZodString;
+                issuer: z.ZodString;
+                value: z.ZodString;
+                packagingLevel: z.ZodEnum<{
+                    unit: "unit";
+                    case: "case";
+                }>;
+                quantity: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>>;
+            assetRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            grossMass: z.ZodOptional<z.ZodObject<{
+                dimension: z.ZodEnum<{
+                    count: "count";
+                    mass: "mass";
+                    volume: "volume";
+                }>;
+                unscaled: z.ZodString;
+                scale: z.ZodNumber;
+                unit: z.ZodString;
+            }, z.core.$strict>>;
+            priceRef: z.ZodOptional<z.ZodString>;
+            logisticsRef: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const catalogDraftPageSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        draftId: z.ZodGUID;
+        productId: z.ZodGUID;
+        revision: z.ZodNumber;
+        status: z.ZodEnum<{
+            open: "open";
+            abandoned: "abandoned";
+        }>;
+        commandKey: z.ZodString;
+        fingerprint: z.ZodString;
+        actorId: z.ZodString;
+        createdAt: z.ZodString;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodGUID>;
+}, z.core.$strict>;
+export declare const catalogDraftRefusalSchema: z.ZodObject<{
+    outcome: z.ZodEnum<{
+        conflict: "conflict";
+        validation_issue: "validation_issue";
+        unauthorized: "unauthorized";
+        dependency_unavailable: "dependency_unavailable";
+    }>;
+    reason: z.ZodString;
+    currentRevision: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const catalogDraftApplyResultSchema: z.ZodUnion<readonly [z.ZodObject<{
+    outcome: z.ZodEnum<{
+        committed: "committed";
+        replayed: "replayed";
+    }>;
+    record: z.ZodObject<{
+        draftId: z.ZodGUID;
+        productId: z.ZodGUID;
+        revision: z.ZodNumber;
+        status: z.ZodEnum<{
+            open: "open";
+            abandoned: "abandoned";
+        }>;
+        commandKey: z.ZodString;
+        fingerprint: z.ZodString;
+        actorId: z.ZodString;
+        createdAt: z.ZodString;
+        payload: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            product: z.ZodObject<{
+                id: z.ZodGUID;
+                type: z.ZodObject<{
+                    key: z.ZodString;
+                    version: z.ZodNumber;
+                }, z.core.$strict>;
+                slug: z.ZodOptional<z.ZodString>;
+                primarySkuId: z.ZodOptional<z.ZodGUID>;
+                dimensions: z.ZodArray<z.ZodString>;
+                sharedContent: z.ZodOptional<z.ZodUnknown & z.ZodType<{} | null, unknown, z.core.$ZodTypeInternals<{} | null, unknown>>>;
+                documentRevision: z.ZodOptional<z.ZodObject<{
+                    id: z.ZodGUID;
+                    productId: z.ZodGUID;
+                    revisionNo: z.ZodNumber;
+                    schemaId: z.ZodString;
+                    documentRef: z.ZodString;
+                    sourceRef: z.ZodString;
+                    digest: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            skus: z.ZodArray<z.ZodObject<{
+                id: z.ZodGUID;
+                productId: z.ZodGUID;
+                code: z.ZodOptional<z.ZodString>;
+                options: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"choice">;
+                    value: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"quantity">;
+                    value: z.ZodObject<{
+                        dimension: z.ZodEnum<{
+                            count: "count";
+                            mass: "mass";
+                            volume: "volume";
+                        }>;
+                        unscaled: z.ZodString;
+                        scale: z.ZodNumber;
+                        unit: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"boolean">;
+                    value: z.ZodBoolean;
+                }, z.core.$strict>], "kind">>;
+                netContent: z.ZodOptional<z.ZodObject<{
+                    dimension: z.ZodEnum<{
+                        count: "count";
+                        mass: "mass";
+                        volume: "volume";
+                    }>;
+                    unscaled: z.ZodString;
+                    scale: z.ZodNumber;
+                    unit: z.ZodString;
+                }, z.core.$strict>>;
+                identifiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    scheme: z.ZodString;
+                    issuer: z.ZodString;
+                    value: z.ZodString;
+                    packagingLevel: z.ZodEnum<{
+                        unit: "unit";
+                        case: "case";
+                    }>;
+                    quantity: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>>;
+                assetRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                grossMass: z.ZodOptional<z.ZodObject<{
+                    dimension: z.ZodEnum<{
+                        count: "count";
+                        mass: "mass";
+                        volume: "volume";
+                    }>;
+                    unscaled: z.ZodString;
+                    scale: z.ZodNumber;
+                    unit: z.ZodString;
+                }, z.core.$strict>>;
+                priceRef: z.ZodOptional<z.ZodString>;
+                logisticsRef: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    outcome: z.ZodEnum<{
+        conflict: "conflict";
+        validation_issue: "validation_issue";
+        unauthorized: "unauthorized";
+        dependency_unavailable: "dependency_unavailable";
+    }>;
+    reason: z.ZodString;
+    currentRevision: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>]>;