daiso 1.0.8 → 1.0.10

package/dist/api/healthChecks.js

@@ -1,178 +1,13 @@
 /**
  * 개별 서비스 헬스 체크 실행기
  */
-const HEALTH_CHECK_CACHE_TTL_MS = 60_000;
+import { EMART24_UPSTREAM_403_PATTERNS, GS25_CLOUDFRONT_403_PATTERNS, HEALTH_CHECKS, SEVENELEVEN_UPSTREAM_403_PATTERNS, } from './healthCheckDefinitions.js';
+import { hasRequiredRepresentativeFields, toCount, toFirstName } from './healthCheckShape.js';
+const HEALTH_CHECK_CACHE_TTL_MS = 300_000;
 const DEFAULT_HEALTH_CHECK_TIMEOUT_MS = 7000;
 const MAX_HEALTH_CHECK_TIMEOUT_MS = 20_000;
 const DEFAULT_HEALTH_CHECK_CONCURRENCY = 1;
 const DEFAULT_HEALTH_CHECK_SLOW_THRESHOLD_MS = 0;
-const GS25_CLOUDFRONT_403_PATTERNS = [
-    '403 Forbidden',
-    'The request could not be satisfied',
-    '403 ERROR',
-];
-const HEALTH_CHECKS = [
-    {
-        id: 'cli.contract',
-        service: 'cli',
-        target: 'api-contract',
-        mode: 'deep',
-        kind: 'cli-contract',
-        path: '/health',
-    },
-    {
-        id: 'daiso.products',
-        service: 'daiso',
-        target: 'products',
-        mode: 'quick',
-        path: '/api/daiso/products?q=%ED%85%8C%EC%9D%B4%ED%94%84&pageSize=1',
-        collectionKey: 'products',
-        requiredFields: ['id', 'name', 'productName', 'itemName', 'goodsName'],
-    },
-    {
-        id: 'cu.stores',
-        service: 'cu',
-        target: 'stores',
-        mode: 'quick',
-        path: '/api/cu/stores?keyword=%EA%B0%95%EB%82%A8&limit=1',
-        collectionKey: 'stores',
-        requiredFields: ['storeCode', 'storeName', 'name'],
-    },
-    {
-        id: 'emart24.products',
-        service: 'emart24',
-        target: 'products',
-        mode: 'quick',
-        path: '/api/emart24/products?keyword=%EC%BB%A4%ED%94%BC&pageSize=1',
-        collectionKey: 'products',
-        requiredFields: ['pluCd', 'goodsName', 'itemName', 'name'],
-    },
-    {
-        id: 'gs25.products',
-        service: 'gs25',
-        target: 'products',
-        mode: 'quick',
-        path: '/api/gs25/products?keyword=%EC%BD%9C%EB%9D%BC&limit=1',
-        collectionKey: 'products',
-        requiredFields: ['itemCode', 'itemName', 'name'],
-        degradedFailurePatterns: GS25_CLOUDFRONT_403_PATTERNS,
-    },
-    {
-        id: 'gs25.stores',
-        service: 'gs25',
-        target: 'stores',
-        mode: 'quick',
-        path: '/api/gs25/stores?keyword=%EA%B0%95%EB%82%A8&limit=1',
-        collectionKey: 'stores',
-        requiredFields: ['storeCode', 'storeName', 'name'],
-    },
-    {
-        id: 'seveneleven.products',
-        service: 'seveneleven',
-        target: 'products',
-        mode: 'quick',
-        path: '/api/seveneleven/products?query=%EC%BB%A4%ED%94%BC&size=1',
-        collectionKey: 'products',
-        requiredFields: ['itemCode', 'itemName', 'productNo', 'name'],
-    },
-    {
-        id: 'lottemart.products',
-        service: 'lottemart',
-        target: 'products',
-        mode: 'quick',
-        path: '/api/lottemart/products?keyword=%EC%BD%9C%EB%9D%BC&storeCode=2301&area=%EC%84%9C%EC%9A%B8&pageLimit=1&source=zetta',
-        collectionKey: 'products',
-        requiredFields: ['productCode', 'name', 'productName'],
-    },
-    {
-        id: 'oliveyoung.products',
-        service: 'oliveyoung',
-        target: 'products',
-        mode: 'quick',
-        path: '/api/oliveyoung/products?keyword=%EB%A6%BD%EB%B0%A4&size=1',
-        collectionKey: 'products',
-        requiredFields: ['goodsNumber', 'goodsName', 'productNo', 'productName', 'name'],
-        timeoutMs: 5000,
-    },
-    {
-        id: 'megabox.theaters',
-        service: 'megabox',
-        target: 'theaters',
-        mode: 'quick',
-        path: '/api/megabox/theaters?keyword=%EA%B0%95%EB%82%A8&limit=1',
-        collectionKey: 'theaters',
-        requiredFields: ['theaterCode', 'theaterName', 'name'],
-    },
-    {
-        id: 'lottecinema.theaters',
-        service: 'lottecinema',
-        target: 'theaters',
-        mode: 'quick',
-        path: '/api/lottecinema/theaters?keyword=%EC%9E%A0%EC%8B%A4&limit=1',
-        collectionKey: 'theaters',
-        requiredFields: ['theaterCode', 'theaterName', 'name'],
-    },
-    {
-        id: 'cgv.theaters',
-        service: 'cgv',
-        target: 'theaters',
-        mode: 'quick',
-        path: '/api/cgv/theaters?keyword=%EA%B0%95%EB%82%A8&limit=1',
-        collectionKey: 'theaters',
-        requiredFields: ['theaterCode', 'theaterName', 'name'],
-    },
-    {
-        id: 'cu.inventory',
-        service: 'cu',
-        target: 'inventory',
-        mode: 'deep',
-        path: '/api/cu/inventory?keyword=%EC%BB%A4%ED%94%BC&size=1&storeLimit=0&storeCheck=false',
-        collectionKey: 'inventoryItems',
-        requiredFields: ['itemCode', 'itemName', 'name'],
-    },
-    {
-        id: 'emart24.inventory',
-        service: 'emart24',
-        target: 'inventory',
-        mode: 'deep',
-        path: '/api/emart24/inventory?keyword=%EC%BB%A4%ED%94%BC&storeKeyword=%EA%B0%95%EB%82%A8&limit=1',
-        collectionKey: 'inventoryItems',
-        requiredFields: ['pluCd', 'goodsName', 'itemName', 'name'],
-    },
-    {
-        id: 'gs25.inventory',
-        service: 'gs25',
-        target: 'inventory',
-        mode: 'deep',
-        path: '/api/gs25/inventory?keyword=%EC%BD%9C%EB%9D%BC&storeKeyword=%EA%B0%95%EB%82%A8&limit=1',
-        collectionKey: 'inventoryItems',
-        requiredFields: ['itemCode', 'itemName', 'name'],
-        degradedFailurePatterns: [
-            '401 Unauthorized',
-            '인증키가 제공되지 않음',
-            ...GS25_CLOUDFRONT_403_PATTERNS,
-        ],
-    },
-    {
-        id: 'seveneleven.inventory',
-        service: 'seveneleven',
-        target: 'inventory',
-        mode: 'deep',
-        path: '/api/seveneleven/inventory?keyword=%EC%BB%A4%ED%94%BC&storeKeyword=%EA%B0%95%EB%82%A8&size=1',
-        collectionKey: 'inventoryItems',
-        requiredFields: ['itemCode', 'itemName', 'productNo', 'name'],
-    },
-    {
-        id: 'oliveyoung.inventory',
-        service: 'oliveyoung',
-        target: 'inventory',
-        mode: 'deep',
-        path: '/api/oliveyoung/inventory?keyword=%EC%84%A0%ED%81%AC%EB%A6%BC&storeKeyword=%EB%AA%85%EB%8F%99&size=1&storeLimit=1&stockCheckLimit=0',
-        collectionKey: 'inventoryProducts',
-        requiredFields: ['goodsNumber', 'goodsName', 'productNo', 'productName', 'name'],
-        timeoutMs: 5000,
-    },
-];
 const healthCheckCache = new Map();
 function clampTimeout(timeoutMs) {
     if (!Number.isFinite(timeoutMs) || timeoutMs < 1) {
@@ -220,109 +55,6 @@ async function mapWithConcurrency(items, concurrency, mapper) {
     }));
     return results;
 }
-function toCount(data) {
-    if (!data || typeof data !== 'object') {
-        return null;
-    }
-    const record = data;
-    if (typeof record.count === 'number') {
-        return record.count;
-    }
-    for (const key of ['products', 'stores', 'theaters', 'movies', 'showtimes']) {
-        const value = record[key];
-        if (Array.isArray(value)) {
-            return value.length;
-        }
-    }
-    if (record.inventory && typeof record.inventory === 'object') {
-        const inventory = record.inventory;
-        for (const key of ['products', 'items']) {
-            const value = inventory[key];
-            if (Array.isArray(value)) {
-                return value.length;
-            }
-        }
-    }
-    return null;
-}
-function toFirstName(data) {
-    if (!data || typeof data !== 'object') {
-        return undefined;
-    }
-    const record = data;
-    for (const key of ['products', 'stores', 'theaters', 'movies', 'showtimes']) {
-        const value = record[key];
-        if (!Array.isArray(value) || !value[0] || typeof value[0] !== 'object') {
-            continue;
-        }
-        const item = value[0];
-        for (const nameKey of ['productName', 'itemName', 'goodsName', 'name', 'storeName', 'theaterName', 'movieName']) {
-            if (typeof item[nameKey] === 'string' && item[nameKey].trim().length > 0) {
-                return item[nameKey].trim();
-            }
-        }
-    }
-    if (record.inventory && typeof record.inventory === 'object') {
-        const inventory = record.inventory;
-        for (const key of ['products', 'items']) {
-            const value = inventory[key];
-            if (!Array.isArray(value) || !value[0] || typeof value[0] !== 'object') {
-                continue;
-            }
-            const item = value[0];
-            for (const nameKey of ['productName', 'itemName', 'goodsName', 'name']) {
-                if (typeof item[nameKey] === 'string' && item[nameKey].trim().length > 0) {
-                    return item[nameKey].trim();
-                }
-            }
-        }
-    }
-    return undefined;
-}
-function getCollectionItems(data, collectionKey) {
-    if (!data || typeof data !== 'object') {
-        return [];
-    }
-    const record = data;
-    if (collectionKey === 'inventoryProducts' || collectionKey === 'inventoryItems') {
-        const inventory = record.inventory;
-        if (!inventory || typeof inventory !== 'object') {
-            return [];
-        }
-        const key = collectionKey === 'inventoryProducts' ? 'products' : 'items';
-        const value = inventory[key];
-        return Array.isArray(value) ? value : [];
-    }
-    if (collectionKey && Array.isArray(record[collectionKey])) {
-        return record[collectionKey];
-    }
-    for (const key of ['products', 'stores', 'theaters', 'movies', 'showtimes']) {
-        /* c8 ignore next -- 현재 정의된 체크는 collectionKey를 명시한다. */
-        if (Array.isArray(record[key])) {
-            return record[key];
-        }
-    }
-    return [];
-}
-function hasRequiredRepresentativeFields(data, collectionKey, requiredFields = []) {
-    /* c8 ignore next -- 현재 정의된 API 체크는 requiredFields를 명시한다. */
-    if (requiredFields.length === 0) {
-        return true;
-    }
-    const items = getCollectionItems(data, collectionKey);
-    if (items.length === 0) {
-        return true;
-    }
-    const first = items[0];
-    if (!first || typeof first !== 'object' || Array.isArray(first)) {
-        return false;
-    }
-    const record = first;
-    return requiredFields.some((field) => {
-        const value = record[field];
-        return typeof value === 'string' ? value.trim().length > 0 : value !== undefined && value !== null;
-    });
-}
 function aggregateStatus(checks) {
     if (checks.length === 0) {
         return 'skipped';
@@ -339,7 +71,16 @@ function shouldDegradeFailedResponse(check, message) {
     return check.degradedFailurePatterns?.some((pattern) => message.includes(pattern)) ?? false;
 }
 function shouldDegradeCliContractPath(path, message) {
-    return path.startsWith('/api/gs25/') && GS25_CLOUDFRONT_403_PATTERNS.some((pattern) => message.includes(pattern));
+    if (path.startsWith('/api/gs25/')) {
+        return GS25_CLOUDFRONT_403_PATTERNS.some((pattern) => message.includes(pattern));
+    }
+    if (path.startsWith('/api/emart24/')) {
+        return EMART24_UPSTREAM_403_PATTERNS.some((pattern) => message.includes(pattern));
+    }
+    if (path.startsWith('/api/seveneleven/')) {
+        return SEVENELEVEN_UPSTREAM_403_PATTERNS.some((pattern) => message.includes(pattern));
+    }
+    return false;
 }
 function resolveCheckTimeoutMs(check, timeoutMs) {
     if (check.timeoutMs === undefined) {

package/dist/api/opinetHandlers.js

@@ -0,0 +1,91 @@
+import { getErrorMessage } from '../core/errors.js';
+import { fetchOpinetAveragePrices, fetchOpinetLowestStations, fetchOpinetStationDetail, fetchOpinetStationsAround, } from '../services/opinet/client.js';
+import { errorResponse, successResponse } from './response.js';
+function parseNumber(value) {
+    if (!value) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function parseInteger(value) {
+    const parsed = parseNumber(value);
+    return parsed === undefined ? undefined : Math.trunc(parsed);
+}
+export async function handleOpinetAveragePrices(c) {
+    try {
+        const result = await fetchOpinetAveragePrices({
+            apiKey: c.env?.OPINET_API_KEY,
+            timeoutMs: parseInteger(c.req.query('timeoutMs')),
+        });
+        return successResponse(c, result, { total: result.count, page: 1, pageSize: result.count });
+    }
+    catch (error) {
+        return errorResponse(c, 'OPINET_AVERAGE_FAILED', getErrorMessage(error), 500);
+    }
+}
+export async function handleOpinetLowestStations(c) {
+    try {
+        const result = await fetchOpinetLowestStations({
+            fuelCode: c.req.query('fuelCode') || c.req.query('prodcd'),
+            areaCode: c.req.query('areaCode') || c.req.query('area'),
+            count: parseInteger(c.req.query('count') || c.req.query('cnt')),
+        }, {
+            apiKey: c.env?.OPINET_API_KEY,
+            timeoutMs: parseInteger(c.req.query('timeoutMs')),
+        });
+        return successResponse(c, result, { total: result.count, page: 1, pageSize: result.count });
+    }
+    catch (error) {
+        return errorResponse(c, 'OPINET_LOWEST_FAILED', getErrorMessage(error), 500);
+    }
+}
+export async function handleOpinetStationsAround(c) {
+    const x = parseNumber(c.req.query('x'));
+    const y = parseNumber(c.req.query('y'));
+    const latitude = parseNumber(c.req.query('latitude') || c.req.query('lat'));
+    const longitude = parseNumber(c.req.query('longitude') || c.req.query('lng'));
+    const location = c.req.query('location') || c.req.query('keyword') || '';
+    const hasKatec = x !== undefined && y !== undefined;
+    const hasCoordinates = latitude !== undefined && longitude !== undefined;
+    const hasLocation = location.trim().length > 0;
+    if (!hasKatec && !hasCoordinates && !hasLocation) {
+        return errorResponse(c, 'MISSING_LOCATION', 'KATEC x/y, 위도/경도(lat/lng), 또는 location 중 하나를 입력해주세요.');
+    }
+    try {
+        const result = await fetchOpinetStationsAround({
+            x,
+            y,
+            latitude,
+            longitude,
+            location,
+            radiusMeters: parseInteger(c.req.query('radiusMeters') || c.req.query('radius')),
+            fuelCode: c.req.query('fuelCode') || c.req.query('prodcd'),
+            sort: c.req.query('sort'),
+        }, {
+            apiKey: c.env?.OPINET_API_KEY,
+            googleMapsApiKey: c.env?.GOOGLE_MAPS_API_KEY,
+            timeoutMs: parseInteger(c.req.query('timeoutMs')),
+        });
+        return successResponse(c, result, { total: result.count, page: 1, pageSize: result.count });
+    }
+    catch (error) {
+        return errorResponse(c, 'OPINET_AROUND_FAILED', getErrorMessage(error), 500);
+    }
+}
+export async function handleOpinetStationDetail(c) {
+    const stationId = c.req.query('stationId') || c.req.query('id') || '';
+    if (!stationId.trim()) {
+        return errorResponse(c, 'MISSING_STATION_ID', 'stationId 또는 id를 입력해주세요.');
+    }
+    try {
+        const result = await fetchOpinetStationDetail(stationId, {
+            apiKey: c.env?.OPINET_API_KEY,
+            timeoutMs: parseInteger(c.req.query('timeoutMs')),
+        });
+        return successResponse(c, result, { total: result.station ? 1 : 0, page: 1, pageSize: result.station ? 1 : 0 });
+    }
+    catch (error) {
+        return errorResponse(c, 'OPINET_DETAIL_FAILED', getErrorMessage(error), 500);
+    }
+}

package/dist/api/routes/feedbackRoutes.js

@@ -0,0 +1,5 @@
+import { handleSubmitDeveloperRequest } from '../feedbackHandlers.js';
+export function registerFeedbackRoutes(app) {
+    app.post('/api/feedback/requests', handleSubmitDeveloperRequest);
+    app.get('/api/feedback/requests', handleSubmitDeveloperRequest);
+}

package/dist/api/routes/healthRoutes.js

@@ -14,6 +14,16 @@ function readHealthCheckToken(headers) {
     }
     return (headers.get('x-health-check-key') || '').trim();
 }
+function isBetterStackHealthProbe(userAgent) {
+    const normalized = (userAgent || '').toLowerCase();
+    return normalized.includes('better stack better uptime bot') || normalized === 'nginx-ssl early hints';
+}
+function isEarlyHintsProbe(userAgent) {
+    return (userAgent || '').trim().toLowerCase() === 'nginx-ssl early hints';
+}
+function canForceFresh(headers) {
+    return parseBoolean(headers.get('x-health-check-force-fresh') || undefined);
+}
 function parseMode(value) {
     if (!value || value === 'quick') {
         return 'quick';
@@ -25,6 +35,10 @@ function parseMode(value) {
 }
 export function registerHealthRoutes(app) {
     app.get('/api/health/checks', async (c) => {
+        const userAgent = c.req.header('User-Agent');
+        if (isEarlyHintsProbe(userAgent)) {
+            return c.body(null, 204);
+        }
         const secret = c.env?.HEALTH_CHECK_SECRET?.trim();
         if (!secret) {
             return errorResponse(c, 'HEALTH_CHECK_SECRET_NOT_CONFIGURED', 'HEALTH_CHECK_SECRET이 설정되어 있지 않습니다.', 503);
@@ -52,7 +66,9 @@ export function registerHealthRoutes(app) {
             timeoutMs,
             slowThresholdMs,
             includeSamples: parseBoolean(c.req.query('includeSamples')),
-            fresh: parseBoolean(c.req.query('fresh')),
+            fresh: parseBoolean(c.req.query('fresh')) &&
+                canForceFresh(c.req.raw.headers) &&
+                !isBetterStackHealthProbe(userAgent),
             cacheBust,
             fetchImpl,
         });

package/dist/api/routes/opinetRoutes.js

@@ -0,0 +1,24 @@
+import { withEdgeCache } from '../../utils/cache.js';
+import { handleOpinetAveragePrices, handleOpinetLowestStations, handleOpinetStationDetail, handleOpinetStationsAround, } from '../opinetHandlers.js';
+export function registerOpinetRoutes(app) {
+    app.get('/api/opinet/average', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 60,
+        staleWhileRevalidateSeconds: 60 * 30,
+        keyPrefix: 'opinet-average-v1',
+    }, () => handleOpinetAveragePrices(c)));
+    app.get('/api/opinet/lowest', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 30,
+        staleWhileRevalidateSeconds: 60 * 10,
+        keyPrefix: 'opinet-lowest-v1',
+    }, () => handleOpinetLowestStations(c)));
+    app.get('/api/opinet/stations/around', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 20,
+        staleWhileRevalidateSeconds: 60 * 5,
+        keyPrefix: 'opinet-around-v1',
+    }, () => handleOpinetStationsAround(c)));
+    app.get('/api/opinet/station', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 60,
+        staleWhileRevalidateSeconds: 60 * 10,
+        keyPrefix: 'opinet-station-v1',
+    }, () => handleOpinetStationDetail(c)));
+}

package/dist/cli/commandOptions.js

@@ -26,6 +26,18 @@ export const COMMAND_OPTION_ALLOWLISTS = {
         'searchSort',
         'storeLimit',
     ],
+    'cgv-theaters': ['help', 'json', 'keyword', 'regionCode', 'playDate', 'lat', 'lng', 'limit'],
+    'cgv-movies': ['help', 'json', 'keyword', 'playDate', 'theaterCode', 'movieCode', 'lat', 'lng'],
+    'cgv-timetable': [
+        'help',
+        'json',
+        'keyword',
+        'playDate',
+        'theaterCode',
+        'movieCode',
+        'lat',
+        'lng',
+    ],
     'lottecinema-theaters': ['help', 'json', 'keyword', 'lat', 'lng', 'playDate', 'limit'],
     'lottecinema-movies': [
         'help',
@@ -84,8 +96,17 @@ export const COMMAND_OPTION_ALLOWLISTS = {
     'gs25-stores': ['help', 'json', 'keyword', 'lat', 'lng', 'serviceCode', 'limit'],
     'gs25-products': ['help', 'json', 'serviceCode', 'limit'],
     'gs25-inventory': ['help', 'json', 'storeKeyword', 'lat', 'lng', 'serviceCode', 'storeLimit'],
-    'seveneleven-products': ['help', 'json', 'page', 'size', 'sort'],
-    'seveneleven-stores': ['help', 'json', 'limit'],
+    'seveneleven-products': ['help', 'json', 'query', 'page', 'size', 'sort'],
+    'seveneleven-stores': ['help', 'json', 'keyword', 'limit'],
+    'seveneleven-inventory': [
+        'help',
+        'json',
+        'keyword',
+        'storeKeyword',
+        'storeLimit',
+        'page',
+        'size',
+    ],
     'seveneleven-popwords': ['help', 'json', 'label'],
     'seveneleven-catalog': ['help', 'json', 'includeIssues', 'includeExhibition', 'limit'],
 };

package/dist/cli/commands/apiCommand.js

@@ -0,0 +1,24 @@
+/**
+ * API 기반 CLI 명령 공통 실행기
+ */
+import { printCommandHelp } from '../../cliHelp.js';
+import { applyOptionsToQuery, parseCliArgs, toQueryOptions, toUrl } from '../args.js';
+import { validateCommandOptions } from '../commandOptions.js';
+import { requestAndPrintResponse } from '../http.js';
+export async function runApiCommand(params) {
+    const parsed = parseCliArgs(params.options);
+    if (parsed.options.help === 'true') {
+        return printCommandHelp(params.command, params.deps.writeOut, params.deps.writeErr);
+    }
+    const errorMessage = params.configure?.(parsed) ?? null;
+    if (errorMessage) {
+        params.deps.writeErr(errorMessage);
+        return 1;
+    }
+    if (validateCommandOptions(params.command, parsed.options, params.deps.writeErr)) {
+        return 1;
+    }
+    const targetUrl = toUrl(params.path);
+    applyOptionsToQuery(targetUrl, toQueryOptions(parsed.options));
+    return await requestAndPrintResponse(params.deps.fetchImpl, params.deps.writeOut, params.deps.writeErr, targetUrl, params.label ?? params.command, parsed.options.json === 'true');
+}

package/dist/cli/commands/cinema.js

@@ -0,0 +1,65 @@
+/**
+ * 영화관 CLI 명령 핸들러
+ */
+import { runApiCommand } from './apiCommand.js';
+function applyKeywordPositional(parsed) {
+    const keyword = parsed.positionals[0];
+    if (keyword) {
+        parsed.options.keyword = keyword;
+    }
+    return null;
+}
+export async function handleLottecinemaTheaters(options, deps) {
+    return await runApiCommand({
+        command: 'lottecinema-theaters',
+        options,
+        deps,
+        path: '/api/lottecinema/theaters',
+        configure: applyKeywordPositional,
+    });
+}
+export async function handleLottecinemaMovies(options, deps) {
+    return await runApiCommand({
+        command: 'lottecinema-movies',
+        options,
+        deps,
+        path: '/api/lottecinema/movies',
+        configure: applyKeywordPositional,
+    });
+}
+export async function handleLottecinemaSeats(options, deps) {
+    return await runApiCommand({
+        command: 'lottecinema-seats',
+        options,
+        deps,
+        path: '/api/lottecinema/seats',
+        configure: applyKeywordPositional,
+    });
+}
+export async function handleCgvTheaters(options, deps) {
+    return await runApiCommand({
+        command: 'cgv-theaters',
+        options,
+        deps,
+        path: '/api/cgv/theaters',
+        configure: applyKeywordPositional,
+    });
+}
+export async function handleCgvMovies(options, deps) {
+    return await runApiCommand({
+        command: 'cgv-movies',
+        options,
+        deps,
+        path: '/api/cgv/movies',
+        configure: applyKeywordPositional,
+    });
+}
+export async function handleCgvTimetable(options, deps) {
+    return await runApiCommand({
+        command: 'cgv-timetable',
+        options,
+        deps,
+        path: '/api/cgv/timetable',
+        configure: applyKeywordPositional,
+    });
+}