@contentstack/cli-variants/lib/utils/variant-api-adapter.d.ts

Variants plugin

import { HttpClient, HttpClientOptions, ContentstackClient, ContentstackConfig } from '@contentstack/cli-utilities';
import { APIConfig, AdapterType, AnyProperty, ExportConfig, VariantOptions, VariantsOption, VariantInterface, VariantEntryStruct, CreateVariantEntryDto, CreateVariantEntryOptions, APIResponse, PublishVariantEntryDto, PublishVariantEntryOptions } from '../types';
import messages from '../messages';
import { AdapterHelper } from './adapter-helper';
export declare class VariantHttpClient<C> extends AdapterHelper<C, HttpClient> implements VariantInterface<C, HttpClient> {
    baseURL: string;
    exportConfig?: ExportConfig;
    constructor(config: APIConfig, options?: HttpClientOptions);
    init(): Promise<void>;
    variantEntry(options: VariantOptions): Promise<{
        entry: {};
    }>;
    /**
     * The function `variantEntries` retrieves variant entries based on specified options and stores them
     * in an array.
     * @param {VariantsOption} options - The `options` parameter in the `variantEntries` function is an
     * object that contains the following properties:
     * @param {Record<string, any>[]} entries - The `entries` parameter in the `variantEntries` function
     * is an array of objects where each object represents a record with key-value pairs. This parameter
     * is used to store the entries retrieved from the API response or passed down recursively when
     * fetching all data.
     * @returns The function `variantEntries` returns a Promise that resolves to an object with an
     * `entries` property containing an array of record objects or an unknown array. The function can
     * also return void if certain conditions are not met.
     */
    variantEntries(options: VariantsOption, entries?: Record<string, any>[]): Promise<{
        entries?: Record<string, any>[] | unknown[];
    } | void>;
    /**
     * Creates a variant entry.
     *
     * @param input - The input data for the variant entry.
     * @param options - The options for creating the variant entry.
     * @param apiParams - Additional parameters for the API.
     * @returns A Promise that resolves to a VariantEntryStruct, a string, or void.
     */
    createVariantEntry(input: CreateVariantEntryDto, options: CreateVariantEntryOptions, apiParams: Record<string, any>): Promise<VariantEntryStruct | string | void>;
    /**
     * Publishes a variant entry.
     *
     * @param input - The input data for publishing the variant entry.
     * @param options - The options for publishing the variant entry.
     * @param apiParams - Additional API parameters.
     * @returns A Promise that resolves to the published variant entry response.
     */
    publishVariantEntry(input: PublishVariantEntryDto, options: PublishVariantEntryOptions, apiParams: Record<string, any>): Promise<void>;
    /**
     * Handles the API response for variant requests.
     * @param res - The API response object.
     * @returns The variant API response data.
     * @throws If the API response status is not within the success range, an error message is thrown.
     */
    handleVariantAPIRes(res: APIResponse): Promise<VariantEntryStruct | {
        entries: VariantEntryStruct[];
        count: number;
    } | string | any>;
}
export declare class VariantManagementSDK<T> extends AdapterHelper<T, ContentstackClient> implements VariantInterface<T, ContentstackClient> {
    apiClient: ContentstackClient;
    exportConfig?: any;
    init(): Promise<void>;
    variantEntry(options: VariantOptions): Promise<{
        entry: {};
    }>;
    variantEntries(options: VariantsOption): Promise<{
        entries: {}[];
    }>;
    createVariantEntry(input: CreateVariantEntryDto, options: CreateVariantEntryOptions, apiParams: Record<string, any>): Promise<VariantEntryStruct | string | void>;
    handleVariantAPIRes(res: APIResponse): Promise<VariantEntryStruct | {
        entries: VariantEntryStruct[];
        count: number;
    } | string>;
    constructQuery(query: Record<string, any>): string | void;
    delay(ms: number): Promise<void>;
}
export declare class VariantAdapter<T> {
    protected variantInstance: T;
    readonly messages: typeof messages;
    exportConfig?: any;
    constructor(config: ContentstackConfig & AnyProperty & AdapterType<T, ContentstackConfig>);
    constructor(config: APIConfig & AdapterType<T, APIConfig & AnyProperty>, options?: HttpClientOptions);
}
export default VariantAdapter;