ebay-mcp 1.14.3 → 1.16.0

package/build/api/listing-management/media.js

@@ -0,0 +1,335 @@
+import { EbayApiError, EndpointInputError, requireObjectEffect, requireStringEffect, } from '../../api/shared/request.js';
+import { getMediaBaseUrl } from '../../config/environment.js';
+import { getErrorMessage } from '../../utils/errors.js';
+import { Data, Effect } from 'effect';
+import { createMediaAttachMethods } from './mediaAttach.js';
+/** Media API base path; the host is `apim` rather than `api` (see {@link getMediaBaseUrl}). */
+export const MEDIA_BASE_PATH = '/commerce/media/v1_beta';
+/** Timeout for binary uploads, which can be far larger than JSON calls. */
+const UPLOAD_TIMEOUT_MS = 10 * 60_000;
+/** How long {@link MediaApi.waitForVideo} waits for eBay processing by default. */
+export const DEFAULT_VIDEO_WAIT_MS = 120_000;
+/** Interval between video status polls. */
+const DEFAULT_POLL_INTERVAL_MS = 5000;
+/** Video statuses eBay treats as final. */
+export const TERMINAL_VIDEO_STATUSES = new Set([
+    'LIVE',
+    'BLOCKED',
+    'PROCESSING_FAILED',
+]);
+/** Failure of one upload in a sequence, carrying what already succeeded. */
+export class MediaUploadError extends Data.TaggedError('MediaUploadError') {
+}
+const idFromLocation = (location) => location?.split('/').filter(Boolean).at(-1);
+/** Media API resource path for an image or video ID, with the ID encoded as one path segment. */
+const resourcePath = (resource, id, suffix = '') => `/${resource}/${encodeURIComponent(id)}${suffix}`;
+const apiFailure = (method, path) => (cause) => new EbayApiError({ method, path, cause });
+const videoStatusFinal = (video) => video.status !== undefined && TERMINAL_VIDEO_STATUSES.has(video.status);
+/**
+ * Validates one of {@link MediaApi.waitForVideo}'s timing inputs.
+ *
+ * A zero, negative, or non-finite poll interval would leave the wait budget
+ * standing still while status requests kept going, so the boundary is checked
+ * before the first poll rather than inside the loop.
+ *
+ * @param value - Caller-supplied duration in milliseconds, or undefined.
+ * @param fallback - Duration used when the caller supplied none.
+ * @param name - Parameter name used in the validation message.
+ * @param minimum - Smallest accepted value.
+ * @returns An Effect with the duration to use, or a tagged input error.
+ */
+const requireDurationMs = (value, fallback, name, minimum) => {
+    if (value === undefined) {
+        return Effect.succeed(fallback);
+    }
+    if (!Number.isFinite(value) || value < minimum) {
+        return Effect.fail(new EndpointInputError({
+            parameter: name,
+            message: `${name} must be a finite number of milliseconds of at least ${minimum} when provided`,
+        }));
+    }
+    return Effect.succeed(value);
+};
+/**
+ * Media API client. Image and video uploads go to eBay's `apim` host and return
+ * the artefacts (EPS URLs, video IDs) that Inventory API listings reference.
+ */
+export class MediaApi {
+    client;
+    /**
+     * Uploads local media and rewrites an inventory item's `product.imageUrls` /
+     * `product.videoIds` — the one composite in this surface; see {@link createMediaAttachMethods}.
+     */
+    attachMediaToInventoryItem;
+    constructor(client, items) {
+        this.client = client;
+        this.attachMediaToInventoryItem = createMediaAttachMethods(items, this).attachMediaToInventoryItem;
+    }
+    url(suffix) {
+        const config = this.client.getConfig();
+        return `${getMediaBaseUrl(config.environment, config.apiBaseUrl)}${MEDIA_BASE_PATH}${suffix}`;
+    }
+    /**
+     * Uploads one picture to eBay Picture Services.
+     *
+     * @param input - File name, MIME type, and contents.
+     * @returns An Effect that succeeds with the EPS URL (and image ID when eBay returns one).
+     *
+     * @example
+     * ```ts
+     * const image = await Effect.runPromise(
+     *   mediaApi.createImageFromFile({ source: 'front.jpg', fileName: 'front.jpg', mimeType: 'image/jpeg', bytes }),
+     * );
+     * ```
+     *
+     * @see https://developer.ebay.com/api-docs/commerce/media/resources/image/methods/createImageFromFile
+     */
+    createImageFromFile = (input) => {
+        const client = this.client;
+        const path = `${MEDIA_BASE_PATH}/image/create_image_from_file`;
+        const url = this.url('/image/create_image_from_file');
+        return Effect.gen(function* () {
+            const upload = yield* requireObjectEffect(input, 'input');
+            const fileName = yield* requireStringEffect(upload.fileName, 'fileName');
+            const form = new FormData();
+            // Copy into a fresh ArrayBuffer-backed view: Blob rejects Node's ArrayBufferLike-typed views.
+            form.append('image', new Blob([new Uint8Array(upload.bytes)], { type: upload.mimeType }), fileName);
+            const response = yield* Effect.tryPromise({
+                try: () => client.postForResponse(url, form, {
+                    absolute: true,
+                    timeoutMs: UPLOAD_TIMEOUT_MS,
+                }),
+                catch: apiFailure('POST', path),
+            });
+            const imageUrl = response.data?.imageUrl;
+            if (!imageUrl) {
+                return yield* Effect.fail(new EbayApiError({
+                    method: 'POST',
+                    path,
+                    cause: new Error('eBay returned no imageUrl for the uploaded picture'),
+                }));
+            }
+            return {
+                source: upload.source,
+                imageId: idFromLocation(response.headers.location),
+                imageUrl,
+                expirationDate: response.data?.expirationDate,
+            };
+        });
+    };
+    /**
+     * Uploads pictures one after another, keeping input order.
+     *
+     * @param files - Files to upload in listing order.
+     * @returns An Effect with every uploaded image, or a `MediaUploadError` naming the first failure and what preceded it.
+     *
+     * @example
+     * ```ts
+     * const { images } = await Effect.runPromise(mediaApi.uploadImageFiles(files));
+     * ```
+     *
+     * @see https://developer.ebay.com/api-docs/commerce/media/resources/image/methods/createImageFromFile
+     */
+    uploadImageFiles = (files) => {
+        const createImageFromFile = this.createImageFromFile;
+        return Effect.gen(function* () {
+            const uploaded = [];
+            for (const [index, file] of files.entries()) {
+                const image = yield* createImageFromFile(file).pipe(Effect.mapError((cause) => new MediaUploadError({
+                    source: file.source,
+                    index,
+                    uploaded: [...uploaded],
+                    cause,
+                    message: `upload of ${file.source} (file ${index + 1} of ${files.length}) failed: ${getErrorMessage(cause)}${uploaded.length > 0 ? `; already uploaded: ${uploaded.map((item) => item.imageUrl).join(', ')}` : ''}`,
+                })));
+                uploaded.push(image);
+            }
+            return { images: uploaded };
+        });
+    };
+    /**
+     * Retrieves the EPS URL and expiry of an uploaded image.
+     *
+     * @param input - Media API image identifier.
+     * @returns An Effect that succeeds with eBay's ImageResponse.
+     *
+     * @example
+     * ```ts
+     * const image = await Effect.runPromise(mediaApi.getImage({ imageId: 'IMG-1' }));
+     * ```
+     *
+     * @see https://developer.ebay.com/api-docs/commerce/media/resources/image/methods/getImage
+     */
+    getImage = (input) => {
+        const client = this.client;
+        const url = (imageId) => this.url(resourcePath('image', imageId));
+        return Effect.gen(function* () {
+            const validated = yield* requireObjectEffect(input, 'input');
+            const imageId = yield* requireStringEffect(validated.imageId, 'imageId');
+            return yield* Effect.tryPromise({
+                try: () => client.get(url(imageId), undefined, { absolute: true }),
+                catch: apiFailure('GET', `${MEDIA_BASE_PATH}${resourcePath('image', imageId)}`),
+            });
+        });
+    };
+    /**
+     * Creates a video resource that a file can then be uploaded to.
+     *
+     * @param input - Title, exact byte size, and optional description.
+     * @returns An Effect that succeeds with the new video ID.
+     *
+     * @example
+     * ```ts
+     * const { videoId } = await Effect.runPromise(mediaApi.createVideo({ title: 'Demo', size: 1024 }));
+     * ```
+     *
+     * @see https://developer.ebay.com/api-docs/commerce/media/resources/video/methods/createVideo
+     */
+    createVideo = (input) => {
+        const client = this.client;
+        const path = `${MEDIA_BASE_PATH}/video`;
+        const url = this.url('/video');
+        return Effect.gen(function* () {
+            const validated = yield* requireObjectEffect(input, 'input');
+            const title = yield* requireStringEffect(validated.title, 'title');
+            const body = {
+                title,
+                size: validated.size,
+                description: validated.description,
+                classification: ['ITEM'],
+            };
+            const response = yield* Effect.tryPromise({
+                try: () => client.postForResponse(url, body, { absolute: true }),
+                catch: apiFailure('POST', path),
+            });
+            const videoId = idFromLocation(response.headers.location);
+            if (!videoId) {
+                return yield* Effect.fail(new EbayApiError({
+                    method: 'POST',
+                    path,
+                    cause: new Error('eBay returned no Location header with the new video ID'),
+                }));
+            }
+            return { videoId };
+        });
+    };
+    /**
+     * Uploads the file for a created video resource.
+     *
+     * @param input - Video ID and file contents (exactly the size given to createVideo).
+     * @returns An Effect that succeeds once eBay accepted the bytes.
+     *
+     * @example
+     * ```ts
+     * await Effect.runPromise(mediaApi.uploadVideo({ videoId: 'VID-1', bytes }));
+     * ```
+     *
+     * @see https://developer.ebay.com/api-docs/commerce/media/resources/video/methods/uploadVideo
+     */
+    uploadVideo = (input) => {
+        const client = this.client;
+        const url = (videoId) => this.url(resourcePath('video', videoId, '/upload'));
+        return Effect.gen(function* () {
+            const validated = yield* requireObjectEffect(input, 'input');
+            const videoId = yield* requireStringEffect(validated.videoId, 'videoId');
+            yield* Effect.tryPromise({
+                try: () => client.post(url(videoId), validated.bytes, {
+                    absolute: true,
+                    timeoutMs: UPLOAD_TIMEOUT_MS,
+                    headers: {
+                        'Content-Type': 'application/octet-stream',
+                        'Content-Length': String(validated.bytes.byteLength),
+                    },
+                }),
+                catch: apiFailure('POST', `${MEDIA_BASE_PATH}${resourcePath('video', videoId, '/upload')}`),
+            });
+        });
+    };
+    /**
+     * Retrieves a video's metadata, processing status, and playlists.
+     *
+     * @param input - Media API video identifier.
+     * @returns An Effect that succeeds with eBay's Video.
+     *
+     * @example
+     * ```ts
+     * const video = await Effect.runPromise(mediaApi.getVideo({ videoId: 'VID-1' }));
+     * ```
+     *
+     * @see https://developer.ebay.com/api-docs/commerce/media/resources/video/methods/getVideo
+     */
+    getVideo = (input) => {
+        const client = this.client;
+        const url = (videoId) => this.url(resourcePath('video', videoId));
+        return Effect.gen(function* () {
+            const validated = yield* requireObjectEffect(input, 'input');
+            const videoId = yield* requireStringEffect(validated.videoId, 'videoId');
+            return yield* Effect.tryPromise({
+                try: () => client.get(url(videoId), undefined, { absolute: true }),
+                catch: apiFailure('GET', `${MEDIA_BASE_PATH}${resourcePath('video', videoId)}`),
+            });
+        });
+    };
+    /**
+     * Polls getVideo until the status is final or the wait budget runs out. The
+     * last sleep is cut to the remaining budget, so the total wait never exceeds
+     * `maxWaitMs` by more than one status request. Both timings are validated
+     * before the first request, so no poll interval can stall the budget.
+     *
+     * @param input - Video ID plus optional wait budget and poll interval.
+     * @returns An Effect with the latest Video; check `status` — it may still be PROCESSING.
+     *
+     * @example
+     * ```ts
+     * const video = await Effect.runPromise(mediaApi.waitForVideo({ videoId: 'VID-1', maxWaitMs: 60_000 }));
+     * ```
+     *
+     * @see https://developer.ebay.com/api-docs/commerce/media/resources/video/methods/getVideo
+     */
+    waitForVideo = (input) => {
+        const getVideo = this.getVideo;
+        return Effect.gen(function* () {
+            const maxWaitMs = yield* requireDurationMs(input.maxWaitMs, DEFAULT_VIDEO_WAIT_MS, 'maxWaitMs', 0);
+            const pollIntervalMs = yield* requireDurationMs(input.pollIntervalMs, DEFAULT_POLL_INTERVAL_MS, 'pollIntervalMs', 1);
+            let waitedMs = 0;
+            let video = yield* getVideo({ videoId: input.videoId });
+            while (!videoStatusFinal(video) && waitedMs < maxWaitMs) {
+                const sleepMs = Math.min(pollIntervalMs, maxWaitMs - waitedMs);
+                yield* Effect.sleep(sleepMs);
+                waitedMs += sleepMs;
+                video = yield* getVideo({ videoId: input.videoId });
+            }
+            return video;
+        });
+    };
+    /**
+     * Runs the whole video lifecycle: create the resource, upload the bytes, wait for processing.
+     *
+     * @param input - File plus optional title, description, and wait settings.
+     * @returns An Effect with the Video (its `videoId` is always set); `status` is LIVE when ready.
+     *
+     * @example
+     * ```ts
+     * const video = await Effect.runPromise(mediaApi.uploadVideoFile({ file }));
+     * ```
+     *
+     * @see https://developer.ebay.com/api-docs/commerce/media/resources/video/methods/uploadVideo
+     */
+    uploadVideoFile = (input) => {
+        const { createVideo, uploadVideo, waitForVideo } = this;
+        return Effect.gen(function* () {
+            const { videoId } = yield* createVideo({
+                title: input.title ?? input.file.fileName,
+                size: input.file.bytes.byteLength,
+                description: input.description,
+            });
+            yield* uploadVideo({ videoId, bytes: input.file.bytes });
+            const video = yield* waitForVideo({
+                videoId,
+                maxWaitMs: input.maxWaitMs,
+                pollIntervalMs: input.pollIntervalMs,
+            });
+            return { ...video, videoId: video.videoId ?? videoId };
+        });
+    };
+}

package/build/api/listing-management/mediaAttach.js

@@ -0,0 +1,145 @@
+import { EndpointInputError } from '../../api/shared/request.js';
+import { getErrorMessage } from '../../utils/errors.js';
+import { Data, Effect } from 'effect';
+/** Attach run that uploaded media but left the inventory item untouched. */
+export class MediaAttachError extends Data.TaggedError('MediaAttachError') {
+}
+const dedupe = (values) => [...new Set(values)];
+/** Keeps only the fields createOrReplaceInventoryItem accepts (drops sku/group metadata). */
+const toInventoryItemBody = (item) => ({
+    availability: item.availability,
+    condition: item.condition,
+    conditionDescription: item.conditionDescription,
+    conditionDescriptors: item.conditionDescriptors,
+    packageWeightAndSize: item.packageWeightAndSize,
+    product: item.product,
+});
+/** `Content-Language` value for an inventory item locale such as `en_US`. */
+const contentLanguageOf = (locale) => locale?.replace('_', '-');
+/**
+ * Merges freshly uploaded media into the product's current media. With
+ * `replaceExisting`, a family is replaced only when the caller supplied files
+ * for it; the other family is carried over untouched.
+ */
+const mergeMedia = (product, input, uploaded) => {
+    const replaceImages = input.replaceExisting === true && input.images.length > 0;
+    const replaceVideos = input.replaceExisting === true && input.videos.length > 0;
+    return {
+        imageUrls: dedupe(replaceImages ? uploaded.imageUrls : [...(product.imageUrls ?? []), ...uploaded.imageUrls]),
+        videoIds: dedupe(replaceVideos ? uploaded.videoIds : [...(product.videoIds ?? []), ...uploaded.videoIds]),
+    };
+};
+/** Media references from the outcomes that can go onto the item. */
+const uploadedMedia = (images, videos) => ({
+    imageUrls: images.flatMap((outcome) => (outcome.imageUrl ? [outcome.imageUrl] : [])),
+    videoIds: videos.flatMap((outcome) => outcome.status !== 'failed' && outcome.videoId ? [outcome.videoId] : []),
+});
+const imageOutcome = (image) => ({
+    source: image.source,
+    kind: 'image',
+    status: 'uploaded',
+    imageUrl: image.imageUrl,
+    imageId: image.imageId,
+    expirationDate: image.expirationDate,
+});
+const videoOutcome = (source, video) => {
+    const base = {
+        source,
+        kind: 'video',
+        videoId: video.videoId,
+        videoStatus: video.status,
+    };
+    if (video.status === 'LIVE') {
+        return { ...base, status: 'uploaded' };
+    }
+    if (video.status === 'BLOCKED' || video.status === 'PROCESSING_FAILED') {
+        const reasons = video.moderation?.rejectReasons?.join(', ');
+        return {
+            ...base,
+            status: 'failed',
+            error: video.statusMessage ?? reasons ?? `eBay reported ${video.status}`,
+        };
+    }
+    return { ...base, status: 'processing' };
+};
+const failedOutcome = (file, kind, cause) => ({
+    source: file.source,
+    kind,
+    status: 'failed',
+    error: getErrorMessage(cause),
+});
+const attachFailure = (summary, result) => new MediaAttachError({
+    message: `${summary}. Results: ${JSON.stringify({ images: result.images, videos: result.videos })}`,
+    result,
+});
+/** Uploads every file, turning each failure into a `failed` outcome instead of aborting. */
+const uploadAll = (media, input) => Effect.gen(function* () {
+    const images = yield* Effect.forEach(input.images, (file) => media.createImageFromFile(file).pipe(Effect.map(imageOutcome), Effect.catchAll((cause) => Effect.succeed(failedOutcome(file, 'image', cause)))));
+    const videos = yield* Effect.forEach(input.videos, (file) => media
+        .uploadVideoFile({
+        file,
+        maxWaitMs: input.maxWaitMs,
+        pollIntervalMs: input.pollIntervalMs,
+    })
+        .pipe(Effect.map((video) => videoOutcome(file.source, video)), Effect.catchAll((cause) => Effect.succeed(failedOutcome(file, 'video', cause)))));
+    return { images, videos };
+});
+/**
+ * Builds the attach orchestration over the inventory-item and media primitives.
+ *
+ * This is deliberately the one composite in the media surface: it checks that the
+ * inventory item exists, uploads every file, then reads the item again right
+ * before the write and rewrites only `product.imageUrls` / `product.videoIds`
+ * on that fresh copy, so edits made during the uploads survive. It never
+ * publishes an offer, and it leaves the item untouched when any upload fails
+ * unless `allowPartial` is set.
+ *
+ * @param items - Inventory item methods used to read and rewrite the item.
+ * @param media - Media API used for the uploads.
+ * @returns The attach method map to merge onto {@link MediaApi}.
+ *
+ * @example
+ * ```ts
+ * const { attachMediaToInventoryItem } = createMediaAttachMethods(items, media);
+ * ```
+ */
+export const createMediaAttachMethods = (items, media) => ({
+    attachMediaToInventoryItem: (input) => Effect.gen(function* () {
+        const total = input.images.length + input.videos.length;
+        if (total === 0) {
+            return yield* Effect.fail(new EndpointInputError({
+                parameter: 'imagePaths',
+                message: 'provide at least one image or video to attach',
+            }));
+        }
+        // Existence check before any upload; the write below re-reads the item.
+        const snapshot = yield* items.getInventoryItem({ sku: input.sku });
+        const { images, videos } = yield* uploadAll(media, input);
+        const failed = [...images, ...videos].filter((outcome) => outcome.status === 'failed');
+        const uploaded = uploadedMedia(images, videos);
+        const result = {
+            sku: input.sku,
+            updated: false,
+            images,
+            videos,
+            ...mergeMedia(snapshot.product ?? {}, input, uploaded),
+        };
+        if (failed.length > 0 && !input.allowPartial) {
+            return yield* Effect.fail(attachFailure(`${failed.length} of ${total} uploads failed; inventory item ${input.sku} was not updated (pass allowPartial: true to attach the successful ones)`, result));
+        }
+        if (uploaded.imageUrls.length + uploaded.videoIds.length === 0) {
+            return yield* Effect.fail(attachFailure(`no media was uploaded successfully; inventory item ${input.sku} was not updated`, result));
+        }
+        // Re-read right before the complete-replacement PUT: the uploads can take
+        // minutes, and the earlier snapshot must not overwrite edits made meanwhile.
+        const latest = yield* items.getInventoryItem({ sku: input.sku });
+        const product = latest.product ?? {};
+        const merged = mergeMedia(product, input, uploaded);
+        yield* items.createOrReplaceInventoryItem({
+            sku: input.sku,
+            contentLanguage: contentLanguageOf(latest.locale),
+            body: { ...toInventoryItemBody(latest), product: { ...product, ...merged } },
+        });
+        return { ...result, ...merged, updated: true };
+    }),
+});

package/build/api/listing-management/offerFormat.js

@@ -0,0 +1,111 @@
+import { BUY_IT_NOW_MARGIN_LABEL, meetsBuyItNowMargin } from '../../api/shared/auctionPricing.js';
+import { EndpointInputError } from '../../api/shared/request.js';
+import { FormatType, ListingDuration } from '../../types/ebayEnums.js';
+import { Effect } from 'effect';
+/** The only `availableQuantity` eBay accepts on an auction offer. */
+const AUCTION_QUANTITY = 1;
+const inputError = (parameter, message) => new EndpointInputError({ parameter, message: `${parameter}: ${message}` });
+const parseAmount = (amount) => {
+    if (amount?.value === undefined) {
+        return;
+    }
+    const parsed = Number(amount.value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+};
+const auctionViolation = (offer, parameter) => {
+    if (offer.listingDuration === ListingDuration.GTC) {
+        return inputError(`${parameter}.listingDuration`, 'AUCTION offers need a day-count listingDuration such as DAYS_7; GTC is only valid for FIXED_PRICE offers');
+    }
+    if (offer.availableQuantity !== undefined && offer.availableQuantity !== AUCTION_QUANTITY) {
+        return inputError(`${parameter}.availableQuantity`, 'AUCTION offers list a single unit; omit availableQuantity or set it to 1');
+    }
+    if (offer.listingPolicies?.eBayPlusIfEligible === true) {
+        return inputError(`${parameter}.listingPolicies.eBayPlusIfEligible`, 'eBayPlusIfEligible is not applicable for AUCTION offers');
+    }
+    if (offer.quantityLimitPerBuyer !== undefined) {
+        return inputError(`${parameter}.quantityLimitPerBuyer`, 'quantityLimitPerBuyer does not apply to AUCTION offers');
+    }
+    if (offer.listingPolicies?.bestOfferTerms?.bestOfferEnabled === true &&
+        offer.pricingSummary?.price !== undefined) {
+        return inputError(`${parameter}.listingPolicies.bestOfferTerms.bestOfferEnabled`, 'an AUCTION offer can carry Best Offer or a Buy It Now price (pricingSummary.price), not both');
+    }
+};
+const fixedPriceViolation = (offer, parameter) => {
+    if (offer.listingDuration !== undefined && offer.listingDuration !== ListingDuration.GTC) {
+        return inputError(`${parameter}.listingDuration`, 'FIXED_PRICE offers must use listingDuration GTC; day-count durations are for AUCTION offers');
+    }
+    const pricing = offer.pricingSummary;
+    if (pricing?.auctionStartPrice !== undefined || pricing?.auctionReservePrice !== undefined) {
+        return inputError(`${parameter}.pricingSummary`, 'auctionStartPrice and auctionReservePrice only apply to AUCTION offers; FIXED_PRICE offers use pricingSummary.price');
+    }
+};
+/** Fields eBay requires when an AUCTION offer is created (its createOffer error catalogue). */
+const auctionCreateViolation = (offer, parameter) => {
+    if (offer.listingDuration === undefined) {
+        return inputError(`${parameter}.listingDuration`, 'listingDuration is required for AUCTION offers (a day count such as DAYS_7)');
+    }
+    if (offer.pricingSummary?.auctionStartPrice === undefined) {
+        return inputError(`${parameter}.pricingSummary.auctionStartPrice`, 'auctionStartPrice is required for AUCTION offers');
+    }
+};
+/** Price relations that hold for any body carrying an opening bid, with or without a format. */
+const auctionPriceViolation = (offer, parameter) => {
+    const start = parseAmount(offer.pricingSummary?.auctionStartPrice);
+    if (start === undefined) {
+        return;
+    }
+    const reserve = parseAmount(offer.pricingSummary?.auctionReservePrice);
+    if (reserve !== undefined && reserve <= start) {
+        return inputError(`${parameter}.pricingSummary.auctionReservePrice`, 'auctionReservePrice must be higher than auctionStartPrice');
+    }
+    const buyItNow = parseAmount(offer.pricingSummary?.price);
+    if (buyItNow !== undefined && !meetsBuyItNowMargin(start, buyItNow)) {
+        return inputError(`${parameter}.pricingSummary.price`, `the Buy It Now price (pricingSummary.price) must be at least ${BUY_IT_NOW_MARGIN_LABEL} higher than auctionStartPrice`);
+    }
+};
+/**
+ * Finds the first eBay listing-format rule an offer body breaks, if any.
+ *
+ * AUCTION offers need a day-count listingDuration and an auctionStartPrice, list a
+ * single unit (availableQuantity omitted or 1), cannot carry per-buyer limits or
+ * eBay Plus, and cannot combine Best Offer with a Buy It Now price; FIXED_PRICE
+ * offers must use GTC and cannot carry auction prices. A reserve must exceed the
+ * opening bid and a Buy It Now price must be at least 30% above it. Update bodies
+ * carry no format, so only the format-free rules apply to them.
+ *
+ * @param offer - Create or update offer body.
+ * @param parameter - Parameter path used to label the failing field (for example `body`).
+ * @returns The tagged input error describing the violation, or undefined when the body is consistent.
+ *
+ * @example
+ * ```ts
+ * const violation = findOfferFormatViolation({ format: 'AUCTION', listingDuration: 'GTC' }, 'body');
+ * ```
+ */
+export const findOfferFormatViolation = (offer, parameter) => {
+    let formatViolation;
+    if (offer.format === FormatType.AUCTION) {
+        formatViolation =
+            auctionViolation(offer, parameter) ?? auctionCreateViolation(offer, parameter);
+    }
+    else if (offer.format === FormatType.FIXED_PRICE) {
+        formatViolation = fixedPriceViolation(offer, parameter);
+    }
+    return formatViolation ?? auctionPriceViolation(offer, parameter);
+};
+/**
+ * Rejects an offer body that mixes AUCTION and FIXED_PRICE fields before it reaches eBay.
+ *
+ * @param offer - Create or update offer body.
+ * @param parameter - Parameter path used to label the failing field (for example `body`).
+ * @returns An Effect that succeeds when the body is consistent and fails with `EndpointInputError` otherwise.
+ *
+ * @example
+ * ```ts
+ * yield* validateOfferFormatEffect(body, 'body');
+ * ```
+ */
+export const validateOfferFormatEffect = (offer, parameter) => {
+    const violation = findOfferFormatViolation(offer, parameter);
+    return violation ? Effect.fail(violation) : Effect.void;
+};