/* generated using openapi-typescript-codegen -- do not edit */
/* istanbul ignore file */
/* tslint:disable */
/* eslint-disable */
import type { CompareProductsOut } from '../models/CompareProductsOut';
import type { CompatibilityOut } from '../models/CompatibilityOut';
import type { ListCategoryProductsOut } from '../models/ListCategoryProductsOut';
import type { ListProductsOut } from '../models/ListProductsOut';
import type { ProductDetailOut } from '../models/ProductDetailOut';
import type { SearchProductsOut } from '../models/SearchProductsOut';
import type { SourcesOut } from '../models/SourcesOut';
import type { CancelablePromise } from '../core/CancelablePromise';
import { OpenAPI } from '../core/OpenAPI';
import { request as __request } from '../core/request';
export class DataProductsService {
    /**
     * Discovery — per-category status + SKU counts
     * Return one row per fixed category with live/coming_soon status.
     * @returns ListProductsOut Successful Response
     * @throws ApiError
     */
    public static productsList(): CancelablePromise<ListProductsOut> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/v1/products/list',
        });
    }
    /**
     * SKUs for one category (filterable via filter[specs.X.op]=v)
     * @returns ListCategoryProductsOut Successful Response
     * @throws ApiError
     */
    public static productsGetCategory({
        category,
        limit = 50,
        offset,
    }: {
        /**
         * Category slug (one of CATEGORIES, e.g. 'hvac' / 'windows').
         */
        category: string,
        /**
         * Page size 1-200
         */
        limit?: number,
        /**
         * Skip N results
         */
        offset?: number,
    }): CancelablePromise<ListCategoryProductsOut> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/v1/products/categories/{category}',
            path: {
                'category': category,
            },
            query: {
                'limit': limit,
                'offset': offset,
            },
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Cross-category text search over mfr + model + name
     * @returns SearchProductsOut Successful Response
     * @throws ApiError
     */
    public static productsSearch({
        q,
        limit = 50,
        offset,
    }: {
        /**
         * Search text (>=2 chars)
         */
        q: string,
        limit?: number,
        offset?: number,
    }): CancelablePromise<SearchProductsOut> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/v1/products/search',
            query: {
                'q': q,
                'limit': limit,
                'offset': offset,
            },
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Side-by-side spec table for up to 5 product IDs
     * @returns CompareProductsOut Successful Response
     * @throws ApiError
     */
    public static productsCompare({
        ids,
    }: {
        /**
         * Comma-separated product IDs (max 5). Example: ids=12,18,42
         */
        ids: string,
    }): CancelablePromise<CompareProductsOut> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/v1/products/compare',
            query: {
                'ids': ids,
            },
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Source authority registry + per-source SKU count
     * @returns SourcesOut Successful Response
     * @throws ApiError
     */
    public static productsSources(): CancelablePromise<SourcesOut> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/v1/products/sources',
        });
    }
    /**
     * Drop-in replacement SKUs for this product
     * Return SKUs marked as drop-in substitutes for ``product_id``.
     * @returns CompatibilityOut Successful Response
     * @throws ApiError
     */
    public static productsGetSubstitutes({
        productId,
        limit = 50,
        offset,
    }: {
        /**
         * Product database ID
         */
        productId: number,
        /**
         * Page size 1-200
         */
        limit?: number,
        /**
         * Skip N results
         */
        offset?: number,
    }): CancelablePromise<CompatibilityOut> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/v1/products/{product_id}/substitutes',
            path: {
                'product_id': productId,
            },
            query: {
                'limit': limit,
                'offset': offset,
            },
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * SKUs compatible with this product (works alongside)
     * Return SKUs marked as compatible (works alongside) ``product_id``.
     * @returns CompatibilityOut Successful Response
     * @throws ApiError
     */
    public static productsGetCompatibility({
        productId,
        limit = 50,
        offset,
    }: {
        /**
         * Product database ID
         */
        productId: number,
        /**
         * Page size 1-200
         */
        limit?: number,
        /**
         * Skip N results
         */
        offset?: number,
    }): CancelablePromise<CompatibilityOut> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/v1/products/{product_id}/compatibility',
            path: {
                'product_id': productId,
            },
            query: {
                'limit': limit,
                'offset': offset,
            },
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Full SKU detail + sources + certifications
     * @returns ProductDetailOut Successful Response
     * @throws ApiError
     */
    public static productsGetDetail({
        productId,
    }: {
        /**
         * Product database ID
         */
        productId: number,
    }): CancelablePromise<ProductDetailOut> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/v1/products/{product_id}',
            path: {
                'product_id': productId,
            },
            errors: {
                422: `Validation Error`,
            },
        });
    }
}