ebay-mcp 1.13.2 → 1.14.0

package/build/utils/communication/notification.js

@@ -1,110 +1,101 @@
-import { z } from 'zod';
-import { idSchema } from '../schema-helpers.js';
+import { z } from '../../utils/effectSchema.js';
+import { idSchema } from '../../utils/schemaHelpers.js';
 /**
- * Zod schemas for Notification API input validation
- * Based on: src/api/communication/notification.ts
+ * Effect-backed schemas for Notification API input validation.
  * OpenAPI spec: docs/sell-apps/communication/commerce_notification_v1_oas3.json
- * Types from: src/types/commerce_notification_v1_oas3.ts
  */
-// Reusable schema for limit parameter (string in API)
+/** Optional positive page size accepted by Notification list endpoints. */
 const limitSchema = z
-    .string({
-    invalid_type_error: 'limit must be a string',
+    .number({
+    invalid_type_error: 'limit must be a number',
     description: 'Maximum number of items to return per page (10-100)',
 })
+    .positive('limit must be a positive number')
     .optional();
-// Reusable schema for continuation token parameter
+/** Optional continuation cursor accepted by Notification list endpoints. */
 const continuationTokenSchema = z
     .string({
     message: 'Continuation token must be a string',
-    invalid_type_error: 'continuation_token must be a string',
+    invalid_type_error: 'continuationToken must be a string',
     description: 'Token for pagination',
 })
     .optional();
-// Reusable schema for object data parameters
-const _objectDataSchema = (name, description) => z.record(z.unknown(), {
-    message: `${name} is required`,
-    required_error: `${name.toLowerCase().replace(/\s+/g, '_')} is required`,
-    invalid_type_error: `${name.toLowerCase().replace(/\s+/g, '_')} must be an object`,
-    description,
-});
-/**
- * Schema for getPublicKey method
- * Endpoint: GET /public_key/{public_key_id}
- * Path: GetPublicKeyParams - public_key_id (required)
- */
+/** Destination delivery configuration schema shared by destination write tools. */
+const deliveryConfigSchema = z
+    .object({
+    endpoint: z
+        .string({
+        invalid_type_error: 'endpoint must be a string',
+        description: 'HTTPS endpoint URL',
+    })
+        .url({
+        message: 'endpoint must be a valid URL',
+    })
+        .optional(),
+    verificationToken: z
+        .string({
+        invalid_type_error: 'verificationToken must be a string',
+        description: 'Verification token (32-80 alphanumeric, underscore, hyphen characters)',
+    })
+        .min(32, 'verificationToken must be at least 32 characters')
+        .max(80, 'verificationToken must be at most 80 characters')
+        .regex(/^[a-zA-Z0-9_-]+$/, 'verificationToken can only contain alphanumeric, underscore, and hyphen characters')
+        .optional(),
+})
+    .optional();
+/** Subscription payload detail schema shared by subscription write tools. */
+const payloadSchema = z
+    .object({
+    deliveryProtocol: z
+        .string({
+        invalid_type_error: 'deliveryProtocol must be a string',
+        description: 'Delivery protocol',
+    })
+        .optional(),
+    format: z
+        .string({
+        invalid_type_error: 'format must be a string',
+        description: 'Payload format',
+    })
+        .optional(),
+    schemaVersion: z
+        .string({
+        invalid_type_error: 'schemaVersion must be a string',
+        description: 'Schema version for the notification topic',
+    })
+        .optional(),
+})
+    .optional();
+/** Schema for getPublicKey input. */
 export const getPublicKeySchema = z.object({
-    public_key_id: idSchema('Public key ID', 'The unique identifier for the public key'),
+    publicKeyId: idSchema('Public key ID', 'The unique identifier for the public key'),
 });
-/**
- * Schema for getConfig method
- * Endpoint: GET /config
- */
+/** Schema for getConfig input. */
 export const getConfigSchema = z.object({});
-/**
- * Schema for updateConfig method
- * Endpoint: PUT /config
- * Body: ConfigType - alertEmail
- */
+/** Schema for updateConfig input. */
 export const updateConfigSchema = z.object({
-    alert_email: z
+    alertEmail: z
         .string({
-        invalid_type_error: 'alert_email must be a string',
+        invalid_type_error: 'alertEmail must be a string',
         description: 'Email address for Notification API alerts',
     })
         .email({
-        message: 'alert_email must be a valid email address',
+        message: 'alertEmail must be a valid email address',
     })
         .optional(),
 });
-/**
- * Schema for getDestinations method
- * Endpoint: GET /destination
- * Query: DestinationParams - continuation_token, limit
- */
+/** Schema for getDestinations input. */
 export const getDestinationsSchema = z.object({
-    continuation_token: continuationTokenSchema,
+    continuationToken: continuationTokenSchema,
     limit: limitSchema,
 });
-/**
- * Schema for getDestination method
- * Endpoint: GET /destination/{destination_id}
- * Path: destination_id (required)
- */
+/** Schema for getDestination input. */
 export const getDestinationSchema = z.object({
-    destination_id: idSchema('Destination ID', 'The unique identifier for the destination'),
+    destinationId: idSchema('Destination ID', 'The unique identifier for the destination'),
 });
-/**
- * Schema for createDestination method
- * Endpoint: POST /destination
- * Body: DestinationRequest - deliveryConfig, name, status
- */
+/** Schema for createDestination input. */
 export const createDestinationSchema = z.object({
-    delivery_config: z
-        .object({
-        endpoint: z
-            .string({
-            invalid_type_error: 'endpoint must be a string',
-            description: 'HTTPS endpoint URL (no internal IPs or localhost)',
-        })
-            .url({
-            message: 'endpoint must be a valid URL',
-        })
-            .optional(),
-        verification_token: z
-            .string({
-            invalid_type_error: 'verification_token must be a string',
-            description: 'Verification token (32-80 alphanumeric, underscore, hyphen characters)',
-        })
-            .min(32, 'verification_token must be at least 32 characters')
-            .max(80, 'verification_token must be at most 80 characters')
-            .regex(/^[a-zA-Z0-9_-]+$/, 'verification_token can only contain alphanumeric, underscore, and hyphen characters')
-            .optional(),
-    }, {
-        invalid_type_error: 'delivery_config must be an object',
-        description: 'Delivery configuration with endpoint and verification token',
-    })
-        .optional(),
+    deliveryConfig: deliveryConfigSchema,
     name: z
         .string({
         invalid_type_error: 'name must be a string',
@@ -118,36 +109,10 @@ export const createDestinationSchema = z.object({
     })
         .optional(),
 });
-/**
- * Schema for updateDestination method
- * Endpoint: PUT /destination/{destination_id}
- * Path: destination_id (required)
- * Body: DestinationRequest
- */
+/** Schema for updateDestination input. */
 export const updateDestinationSchema = z.object({
-    destination_id: idSchema('Destination ID', 'The unique identifier for the destination'),
-    delivery_config: z
-        .object({
-        endpoint: z
-            .string({
-            invalid_type_error: 'endpoint must be a string',
-            description: 'HTTPS endpoint URL',
-        })
-            .url({
-            message: 'endpoint must be a valid URL',
-        })
-            .optional(),
-        verification_token: z
-            .string({
-            invalid_type_error: 'verification_token must be a string',
-            description: 'Verification token (32-80 characters)',
-        })
-            .min(32)
-            .max(80)
-            .regex(/^[a-zA-Z0-9_-]+$/)
-            .optional(),
-    })
-        .optional(),
+    destinationId: idSchema('Destination ID', 'The unique identifier for the destination'),
+    deliveryConfig: deliveryConfigSchema,
     name: z
         .string({
         invalid_type_error: 'name must be a string',
@@ -161,117 +126,51 @@ export const updateDestinationSchema = z.object({
     })
         .optional(),
 });
-/**
- * Schema for deleteDestination method
- * Endpoint: DELETE /destination/{destination_id}
- * Path: destination_id (required)
- */
+/** Schema for deleteDestination input. */
 export const deleteDestinationSchema = z.object({
-    destination_id: idSchema('Destination ID', 'The unique identifier for the destination'),
+    destinationId: idSchema('Destination ID', 'The unique identifier for the destination'),
 });
-/**
- * Schema for getSubscriptions method
- * Endpoint: GET /subscription
- * Query: SubscriptionParams - continuation_token, limit
- */
+/** Schema for getSubscriptions input. */
 export const getSubscriptionsSchema = z.object({
     limit: limitSchema,
-    continuation_token: continuationTokenSchema,
+    continuationToken: continuationTokenSchema,
 });
-/**
- * Schema for createSubscription method
- * Endpoint: POST /subscription
- * Body: CreateSubscriptionRequest - destinationId, payload, status, topicId
- */
+/** Schema for createSubscription input. */
 export const createSubscriptionSchema = z.object({
-    destination_id: z
+    destinationId: z
         .string({
-        invalid_type_error: 'destination_id must be a string',
+        invalid_type_error: 'destinationId must be a string',
         description: 'The unique identifier of the destination endpoint',
     })
         .optional(),
-    payload: z
-        .object({
-        delivery_protocol: z
-            .string({
-            invalid_type_error: 'delivery_protocol must be a string',
-            description: 'Delivery protocol (currently only HTTPS is supported)',
-        })
-            .optional(),
-        format: z
-            .string({
-            invalid_type_error: 'format must be a string',
-            description: 'Payload format (currently only JSON is supported)',
-        })
-            .optional(),
-        schema_version: z
-            .string({
-            invalid_type_error: 'schema_version must be a string',
-            description: 'Schema version for the notification topic',
-        })
-            .optional(),
-    }, {
-        invalid_type_error: 'payload must be an object',
-        description: 'Payload configuration',
-    })
-        .optional(),
+    payload: payloadSchema,
     status: z
         .string({
         invalid_type_error: 'status must be a string',
         description: 'Status: ENABLED or DISABLED',
     })
         .optional(),
-    topic_id: z
+    topicId: z
         .string({
-        invalid_type_error: 'topic_id must be a string',
+        invalid_type_error: 'topicId must be a string',
         description: 'The unique identifier of the notification topic',
     })
         .optional(),
 });
-/**
- * Schema for getSubscription method
- * Endpoint: GET /subscription/{subscription_id}
- * Path: subscription_id (required)
- */
+/** Schema for getSubscription input. */
 export const getSubscriptionSchema = z.object({
-    subscription_id: idSchema('Subscription ID', 'The unique identifier for the subscription'),
+    subscriptionId: idSchema('Subscription ID', 'The unique identifier for the subscription'),
 });
-/**
- * Schema for updateSubscription method
- * Endpoint: PUT /subscription/{subscription_id}
- * Path: subscription_id (required)
- * Body: UpdateSubscriptionRequest - destinationId, payload, status
- */
+/** Schema for updateSubscription input. */
 export const updateSubscriptionSchema = z.object({
-    subscription_id: idSchema('Subscription ID', 'The unique identifier for the subscription'),
-    destination_id: z
+    subscriptionId: idSchema('Subscription ID', 'The unique identifier for the subscription'),
+    destinationId: z
         .string({
-        invalid_type_error: 'destination_id must be a string',
+        invalid_type_error: 'destinationId must be a string',
         description: 'The unique identifier of the destination',
     })
         .optional(),
-    payload: z
-        .object({
-        delivery_protocol: z
-            .string({
-            invalid_type_error: 'delivery_protocol must be a string',
-            description: 'Delivery protocol',
-        })
-            .optional(),
-        format: z
-            .string({
-            invalid_type_error: 'format must be a string',
-            description: 'Payload format',
-        })
-            .optional(),
-        schema_version: z
-            .string({
-            invalid_type_error: 'schema_version must be a string',
-            description: 'Schema version',
-        })
-            .optional(),
-    })
-        .optional(),
+    payload: payloadSchema,
     status: z
         .string({
         invalid_type_error: 'status must be a string',
@@ -279,85 +178,46 @@ export const updateSubscriptionSchema = z.object({
     })
         .optional(),
 });
-/**
- * Schema for deleteSubscription method
- * Endpoint: DELETE /subscription/{subscription_id}
- * Path: subscription_id (required)
- */
+/** Schema for deleteSubscription input. */
 export const deleteSubscriptionSchema = z.object({
-    subscription_id: idSchema('Subscription ID', 'The unique identifier for the subscription'),
+    subscriptionId: idSchema('Subscription ID', 'The unique identifier for the subscription'),
 });
-/**
- * Schema for disableSubscription method
- * Endpoint: POST /subscription/{subscription_id}/disable
- * Path: subscription_id (required)
- */
+/** Schema for disableSubscription input. */
 export const disableSubscriptionSchema = z.object({
-    subscription_id: idSchema('Subscription ID', 'The unique identifier for the subscription'),
+    subscriptionId: idSchema('Subscription ID', 'The unique identifier for the subscription'),
 });
-/**
- * Schema for enableSubscription method
- * Endpoint: POST /subscription/{subscription_id}/enable
- * Path: subscription_id (required)
- */
+/** Schema for enableSubscription input. */
 export const enableSubscriptionSchema = z.object({
-    subscription_id: idSchema('Subscription ID', 'The unique identifier for the subscription'),
+    subscriptionId: idSchema('Subscription ID', 'The unique identifier for the subscription'),
 });
-/**
- * Schema for testSubscription method
- * Endpoint: POST /subscription/{subscription_id}/test
- * Path: subscription_id (required)
- */
+/** Schema for testSubscription input. */
 export const testSubscriptionSchema = z.object({
-    subscription_id: idSchema('Subscription ID', 'The unique identifier for the subscription'),
+    subscriptionId: idSchema('Subscription ID', 'The unique identifier for the subscription'),
 });
-/**
- * Schema for getTopic method
- * Endpoint: GET /topic/{topic_id}
- * Path: topic_id (required)
- */
+/** Schema for getTopic input. */
 export const getTopicSchema = z.object({
-    topic_id: idSchema('Topic ID', 'The unique identifier for the topic'),
+    topicId: idSchema('Topic ID', 'The unique identifier for the topic'),
 });
-/**
- * Schema for getTopics method
- * Endpoint: GET /topic
- * Query: TopicParams - continuation_token, limit
- */
+/** Schema for getTopics input. */
 export const getTopicsSchema = z.object({
     limit: limitSchema,
-    continuation_token: continuationTokenSchema,
+    continuationToken: continuationTokenSchema,
 });
-/**
- * Schema for createSubscriptionFilter method
- * Endpoint: POST /subscription/{subscription_id}/filter
- * Path: subscription_id (required)
- * Body: CreateSubscriptionFilterRequest - filterSchema
- */
+/** Schema for createSubscriptionFilter input. */
 export const createSubscriptionFilterSchema = z.object({
-    subscription_id: idSchema('Subscription ID', 'The unique identifier for the subscription'),
-    filter_schema: z
-        .record(z.unknown(), {
-        invalid_type_error: 'filter_schema must be an object',
-        description: 'Valid JSON Schema Core document (version 2020-12 or later) to filter notifications',
-    })
-        .optional(),
+    subscriptionId: idSchema('Subscription ID', 'The unique identifier for the subscription'),
+    filterSchema: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .describe('Valid JSON Schema Core document (version 2020-12 or later) to filter notifications'),
 });
-/**
- * Schema for getSubscriptionFilter method
- * Endpoint: GET /subscription/{subscription_id}/filter/{filter_id}
- * Path: subscription_id (required), filter_id (required)
- */
+/** Schema for getSubscriptionFilter input. */
 export const getSubscriptionFilterSchema = z.object({
-    subscription_id: idSchema('Subscription ID', 'The unique identifier for the subscription'),
-    filter_id: idSchema('Filter ID', 'The unique identifier for the filter'),
+    subscriptionId: idSchema('Subscription ID', 'The unique identifier for the subscription'),
+    filterId: idSchema('Filter ID', 'The unique identifier for the filter'),
 });
-/**
- * Schema for deleteSubscriptionFilter method
- * Endpoint: DELETE /subscription/{subscription_id}/filter/{filter_id}
- * Path: subscription_id (required), filter_id (required)
- */
+/** Schema for deleteSubscriptionFilter input. */
 export const deleteSubscriptionFilterSchema = z.object({
-    subscription_id: idSchema('Subscription ID', 'The unique identifier for the subscription'),
-    filter_id: idSchema('Filter ID', 'The unique identifier for the filter'),
+    subscriptionId: idSchema('Subscription ID', 'The unique identifier for the subscription'),
+    filterId: idSchema('Filter ID', 'The unique identifier for the filter'),
 });

package/build/utils/{date-converter.js → dateConverter.js}

@@ -1,8 +1,12 @@
+import { Data, Effect } from 'effect';
+/** Utility functions for date/timestamp conversion and validation. */
+/** Tagged failure returned when user-supplied date input cannot be parsed. */
+export class DateConversionError extends Data.TaggedError('DateConversionError') {
+}
+/** Return a tagged date-conversion failure for invalid user input. */
+const invalidDateInput = (input, message) => Effect.fail(new DateConversionError({ input, message }));
 /**
- * Utility functions for date/timestamp conversion and validation
- */
-/**
- * Convert a date string or Date object to Unix timestamp (milliseconds)
+ * Convert a date string or Date object to Unix timestamp (milliseconds).
  *
  * Supported formats:
  * - ISO 8601: "2025-01-15T10:30:00Z" or "2025-01-15T10:30:00.000Z"
@@ -12,39 +16,43 @@
  * - Relative time: "in 2 hours", "in 7200 seconds"
  *
  * @param dateInput - Date string, Date object, or Unix timestamp
- * @returns Unix timestamp in milliseconds
- * @throws Error if date format is invalid
+ * @returns An Effect that succeeds with a Unix timestamp in milliseconds.
+ *
+ * @example
+ * ```ts
+ * const timestamp = await Effect.runPromise(convertToTimestamp('2026-01-15T10:30:00Z'));
+ * ```
  */
-export function convertToTimestamp(dateInput) {
+export const convertToTimestamp = (dateInput) => {
     // If already a number, handle as timestamp
     if (typeof dateInput === 'number') {
         // If appears to be seconds (less than year 2100 in milliseconds)
-        if (dateInput < 4102444800000) {
+        if (dateInput < 4_102_444_800_000) {
             // Could be seconds, check if reasonable
             const now = Date.now();
             const asSeconds = dateInput * 1000;
             // If multiplying by 1000 gives reasonable future date, it's seconds
             if (asSeconds > now - 100 * 365 * 24 * 60 * 60 * 1000) {
-                return Math.floor(asSeconds);
+                return Effect.succeed(Math.floor(asSeconds));
             }
         }
         // Already milliseconds
-        return Math.floor(dateInput);
+        return Effect.succeed(Math.floor(dateInput));
     }
     // If Date object
     if (dateInput instanceof Date) {
         const timestamp = dateInput.getTime();
-        if (isNaN(timestamp)) {
-            throw new Error('Invalid Date object');
+        if (Number.isNaN(timestamp)) {
+            return invalidDateInput(dateInput, 'Invalid Date object');
         }
-        return timestamp;
+        return Effect.succeed(timestamp);
     }
     // If string, try parsing
     if (typeof dateInput === 'string') {
         // Handle relative time: "in X hours/minutes/seconds"
         const relativeMatch = /^in\s+(\d+)\s+(hours?|minutes?|seconds?|days?)$/i.exec(dateInput);
         if (relativeMatch) {
-            const amount = parseInt(relativeMatch[1], 10);
+            const amount = Number.parseInt(relativeMatch[1], 10);
             const unit = relativeMatch[2].toLowerCase();
             let multiplier = 1000; // Default to seconds
             if (unit.startsWith('minute'))
@@ -53,17 +61,17 @@ export function convertToTimestamp(dateInput) {
                 multiplier = 60 * 60 * 1000;
             else if (unit.startsWith('day'))
                 multiplier = 24 * 60 * 60 * 1000;
-            return Date.now() + amount * multiplier;
+            return Effect.succeed(Date.now() + amount * multiplier);
         }
         // Try parsing as ISO date or other standard format
         const parsed = Date.parse(dateInput);
-        if (isNaN(parsed)) {
-            throw new Error(`Invalid date format: ${dateInput}. Supported formats: ISO 8601, Unix timestamp, or relative time (e.g., "in 2 hours")`);
+        if (Number.isNaN(parsed)) {
+            return invalidDateInput(dateInput, `Invalid date format: ${dateInput}. Supported formats: ISO 8601, Unix timestamp, or relative time (e.g., "in 2 hours")`);
         }
-        return parsed;
+        return Effect.succeed(parsed);
     }
-    throw new Error(`Unsupported date input type: ${typeof dateInput}`);
-}
+    return invalidDateInput(dateInput, `Unsupported date input type: ${typeof dateInput}`);
+};
 /**
  * Calculate expiry timestamp from duration in seconds
  * Useful for eBay token responses which provide expires_in in seconds
@@ -71,30 +79,45 @@ export function convertToTimestamp(dateInput) {
  * @param expiresInSeconds - Duration in seconds (e.g., 7200 for 2 hours)
  * @param fromTimestamp - Optional base timestamp (defaults to now)
  * @returns Expiry timestamp in milliseconds
+ *
+ * @example
+ * ```ts
+ * const expiry = calculateExpiry(7200, Date.UTC(2026, 0, 1));
+ * ```
  */
-export function calculateExpiry(expiresInSeconds, fromTimestamp) {
+export const calculateExpiry = (expiresInSeconds, fromTimestamp) => {
     const baseTime = fromTimestamp ?? Date.now();
     return baseTime + expiresInSeconds * 1000;
-}
+};
 /**
  * Check if a timestamp is expired
  *
  * @param expiryTimestamp - Expiry timestamp in milliseconds
  * @param bufferSeconds - Optional buffer time in seconds (default: 60)
  * @returns true if expired (or will expire within buffer time)
+ *
+ * @example
+ * ```ts
+ * const expired = isExpired(Date.now() - 1, 0);
+ * ```
  */
-export function isExpired(expiryTimestamp, bufferSeconds = 60) {
+export const isExpired = (expiryTimestamp, bufferSeconds = 60) => {
     const now = Date.now();
     const buffer = bufferSeconds * 1000;
     return now + buffer >= expiryTimestamp;
-}
+};
 /**
  * Get human-readable time remaining until expiry
  *
  * @param expiryTimestamp - Expiry timestamp in milliseconds
  * @returns Human-readable string (e.g., "2 hours 15 minutes")
+ *
+ * @example
+ * ```ts
+ * const remaining = getTimeRemaining(Date.now() + 120_000);
+ * ```
  */
-export function getTimeRemaining(expiryTimestamp) {
+export const getTimeRemaining = (expiryTimestamp) => {
     const now = Date.now();
     const diff = expiryTimestamp - now;
     if (diff <= 0) {
@@ -117,17 +140,26 @@ export function getTimeRemaining(expiryTimestamp) {
         return `${minutes} minute${minutes > 1 ? 's' : ''}${remainingSeconds > 0 ? ` ${remainingSeconds} second${remainingSeconds > 1 ? 's' : ''}` : ''}`;
     }
     return `${seconds} second${seconds > 1 ? 's' : ''}`;
-}
+};
 /**
  * Validate access and refresh token expiry timestamps and return renewal guidance.
+ *
+ * @param accessTokenExpiry - Access-token expiry timestamp in milliseconds.
+ * @param refreshTokenExpiry - Refresh-token expiry timestamp in milliseconds.
+ * @returns Token validity flags, remaining-time labels, warnings, and recommendations.
+ *
+ * @example
+ * ```ts
+ * const validation = validateTokenExpiry(accessTokenExpiry, refreshTokenExpiry);
+ * ```
  */
-export function validateTokenExpiry(accessTokenExpiry, refreshTokenExpiry) {
+export const validateTokenExpiry = (accessTokenExpiry, refreshTokenExpiry) => {
     const warnings = [];
     const recommendations = [];
     const accessExpired = isExpired(accessTokenExpiry, 0);
     const accessExpiringSoon = isExpired(accessTokenExpiry, 300); // 5 minutes
     const refreshExpired = isExpired(refreshTokenExpiry, 0);
-    const refreshExpiringSoon = isExpired(refreshTokenExpiry, 86400); // 1 day
+    const refreshExpiringSoon = isExpired(refreshTokenExpiry, 86_400); // 1 day
     let accessTokenStatus = 'valid';
     let refreshTokenStatus = 'valid';
     if (accessExpired) {
@@ -152,7 +184,7 @@ export function validateTokenExpiry(accessTokenExpiry, refreshTokenExpiry) {
         recommendations.push('Consider prompting user to re-authorize before refresh token expires');
     }
     return {
-        valid: !accessExpired && !refreshExpired,
+        valid: !(accessExpired || refreshExpired),
         accessTokenStatus,
         refreshTokenStatus,
         accessTokenRemaining: getTimeRemaining(accessTokenExpiry),
@@ -160,4 +192,4 @@ export function validateTokenExpiry(accessTokenExpiry, refreshTokenExpiry) {
         warnings,
         recommendations,
     };
-}
+};