import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from '@angular/common/http';
import { Observable } from 'rxjs';
import { AnnulSingleStructuredDataResponse } from '../model/annulSingleStructuredDataResponse';
import { GetRecipeComposerResponse } from '../model/getRecipeComposerResponse';
import { GetRecipeResponse } from '../model/getRecipeResponse';
import { ResourceListOfGetRecipeComposerResponse } from '../model/resourceListOfGetRecipeComposerResponse';
import { ResourceListOfGetRecipeResponse } from '../model/resourceListOfGetRecipeResponse';
import { UpsertRecipeComposerRequest } from '../model/upsertRecipeComposerRequest';
import { UpsertRecipeRequest } from '../model/upsertRecipeRequest';
import { UpsertSingleStructuredDataResponse } from '../model/upsertSingleStructuredDataResponse';
import { Configuration } from '../configuration';
import * as i0 from "@angular/core";
export declare class ConfigurationRecipeService {
    protected httpClient: HttpClient;
    protected basePath: string;
    defaultHeaders: HttpHeaders;
    configuration: Configuration;
    encoder: HttpParameterCodec;
    constructor(httpClient: HttpClient, basePath: string | string[], configuration: Configuration);
    private addToHttpParams;
    private addToHttpParamsRecursive;
    /**
     * DeleteConfigurationRecipe: Delete a Configuration Recipe, assuming that it is present.
     * Delete the specified Configuration Recipe from a single scope.                The response will return either detail of the deleted item, or an explanation (failure) as to why this did not succeed.                It is important to always check for any unsuccessful response.
     * @param scope The scope of the Configuration Recipe to delete.
     * @param code The Configuration Recipe to delete.
     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
     * @param reportProgress flag to report request and response progress.
     */
    deleteConfigurationRecipe(scope: string, code: string, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<AnnulSingleStructuredDataResponse>;
    deleteConfigurationRecipe(scope: string, code: string, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<AnnulSingleStructuredDataResponse>>;
    deleteConfigurationRecipe(scope: string, code: string, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<AnnulSingleStructuredDataResponse>>;
    /**
     * [EXPERIMENTAL] DeleteRecipeComposer: Delete a Recipe Composer, assuming that it is present.
     * Delete the specified Recipe Composer from a single scope.                The response will return either detail of the deleted item, or an explanation (failure) as to why this did not succeed.                It is important to always check for any unsuccessful response.
     * @param scope The scope of the Recipe Composer to delete.
     * @param code The Recipe Composer to delete.
     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
     * @param reportProgress flag to report request and response progress.
     */
    deleteRecipeComposer(scope: string, code: string, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<AnnulSingleStructuredDataResponse>;
    deleteRecipeComposer(scope: string, code: string, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<AnnulSingleStructuredDataResponse>>;
    deleteRecipeComposer(scope: string, code: string, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<AnnulSingleStructuredDataResponse>>;
    /**
     * GetConfigurationRecipe: Get Configuration Recipe
     * Get a Configuration Recipe from a single scope.                The response will return either the recipe that has been stored, or a failure explaining why the request was unsuccessful.                It is important to always check for any unsuccessful requests (failures).
     * @param scope The scope of the Configuration Recipe to retrieve.
     * @param code The name of the recipe to retrieve the data for.
     * @param asAt The asAt datetime at which to retrieve the Configuration Recipe. Defaults to return the latest version if not specified.
     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
     * @param reportProgress flag to report request and response progress.
     */
    getConfigurationRecipe(scope: string, code: string, asAt?: string, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<GetRecipeResponse>;
    getConfigurationRecipe(scope: string, code: string, asAt?: string, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<GetRecipeResponse>>;
    getConfigurationRecipe(scope: string, code: string, asAt?: string, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<GetRecipeResponse>>;
    /**
     * [EXPERIMENTAL] GetDerivedRecipe: Get Configuration Recipe either from the store or expanded from a Recipe Composer.
     * If scope-code is referring to a Configuration Recipe it is returned, if it refers to Recipe Composer, it is expanded into a Configuration Recipe and returned.
     * @param scope The scope of the Configuration Recipe or Recipe Composer to return.
     * @param code The code of the Configuration Recipe or Recipe Composer to return.
     * @param asAt The asAt datetime at which to retrieve the Configuration Recipe. Defaults to return the latest version if not specified.
     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
     * @param reportProgress flag to report request and response progress.
     */
    getDerivedRecipe(scope: string, code: string, asAt?: string, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<GetRecipeResponse>;
    getDerivedRecipe(scope: string, code: string, asAt?: string, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<GetRecipeResponse>>;
    getDerivedRecipe(scope: string, code: string, asAt?: string, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<GetRecipeResponse>>;
    /**
     * [EXPERIMENTAL] GetRecipeComposer: Get Recipe Composer
     * Get a Recipe Composer from a single scope.                The response will return either the recipe composer that has been stored, or a failure explaining why the request was unsuccessful.                It is important to always check for any unsuccessful requests (failures).
     * @param scope The scope of the Recipe Composer to retrieve.
     * @param code The name of the Recipe Composer to retrieve the data for.
     * @param asAt The asAt datetime at which to retrieve the Recipe Composer. Defaults to return the latest version if not specified.
     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
     * @param reportProgress flag to report request and response progress.
     */
    getRecipeComposer(scope: string, code: string, asAt?: string, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<GetRecipeComposerResponse>;
    getRecipeComposer(scope: string, code: string, asAt?: string, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<GetRecipeComposerResponse>>;
    getRecipeComposer(scope: string, code: string, asAt?: string, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<GetRecipeComposerResponse>>;
    /**
     * [EXPERIMENTAL] GetRecipeComposerResolvedInline: Given a Recipe Composer, this endpoint expands into a Configuration Recipe without persistence. Primarily used for testing purposes.
     * Resolves an inline recipe composer into a ConfigurationRecipe.
     * @param upsertRecipeComposerRequest Recipe composer used to expand into the Configuration Recipe.
     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
     * @param reportProgress flag to report request and response progress.
     */
    getRecipeComposerResolvedInline(upsertRecipeComposerRequest: UpsertRecipeComposerRequest, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<GetRecipeResponse>;
    getRecipeComposerResolvedInline(upsertRecipeComposerRequest: UpsertRecipeComposerRequest, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<GetRecipeResponse>>;
    getRecipeComposerResolvedInline(upsertRecipeComposerRequest: UpsertRecipeComposerRequest, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<GetRecipeResponse>>;
    /**
     * ListConfigurationRecipes: List the set of Configuration Recipes
     * List the set of configuration recipes at the specified date/time and scope. Note this only returns recipes stored directly and does not include any recipes expanded from recipe composers.
     * @param asAt The asAt datetime at which to list the Configuration Recipes. Defaults to latest if not specified.
     * @param filter Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.
     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
     * @param reportProgress flag to report request and response progress.
     */
    listConfigurationRecipes(asAt?: string, filter?: string, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<ResourceListOfGetRecipeResponse>;
    listConfigurationRecipes(asAt?: string, filter?: string, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<ResourceListOfGetRecipeResponse>>;
    listConfigurationRecipes(asAt?: string, filter?: string, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<ResourceListOfGetRecipeResponse>>;
    /**
     * [EXPERIMENTAL] ListDerivedRecipes: List the complete set of all Configuration Recipes, both from the configuration recipe store and also from expanded recipe composers.
     * This endpoints returns a union of the output of ListConfigurationRecipes and the resolved Recipe Composers from the ListRecipeComposers endpoints.
     * @param asAt The asAt datetime at which to list the Configuration Recipes. Defaults to latest if not specified.
     * @param filter Expression to filter the result set, note this functionality is not yet enabled for this endpoint.
     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
     * @param reportProgress flag to report request and response progress.
     */
    listDerivedRecipes(asAt?: string, filter?: string, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<ResourceListOfGetRecipeResponse>;
    listDerivedRecipes(asAt?: string, filter?: string, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<ResourceListOfGetRecipeResponse>>;
    listDerivedRecipes(asAt?: string, filter?: string, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<ResourceListOfGetRecipeResponse>>;
    /**
     * [EXPERIMENTAL] ListRecipeComposers: List the set of Recipe Composers
     * List the set of Recipe Composers at the specified date/time and scope
     * @param asAt The asAt datetime at which to list the Recipes Composers. Defaults to latest if not specified.
     * @param filter Expression to filter the result set, note this functionality is not yet enabled for this endpoint.
     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
     * @param reportProgress flag to report request and response progress.
     */
    listRecipeComposers(asAt?: string, filter?: string, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<ResourceListOfGetRecipeComposerResponse>;
    listRecipeComposers(asAt?: string, filter?: string, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<ResourceListOfGetRecipeComposerResponse>>;
    listRecipeComposers(asAt?: string, filter?: string, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<ResourceListOfGetRecipeComposerResponse>>;
    /**
     * UpsertConfigurationRecipe: Upsert a Configuration Recipe. This creates or updates the data in Lusid.
     * Update or insert one Configuration Recipe in a single scope. An item will be updated if it already exists  and inserted if it does not.                The response will return the successfully updated or inserted Configuration Recipe or failure message if unsuccessful                It is important to always check to verify success (or failure).
     * @param upsertRecipeRequest The Configuration Recipe to update or insert
     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
     * @param reportProgress flag to report request and response progress.
     */
    upsertConfigurationRecipe(upsertRecipeRequest: UpsertRecipeRequest, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<UpsertSingleStructuredDataResponse>;
    upsertConfigurationRecipe(upsertRecipeRequest: UpsertRecipeRequest, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<UpsertSingleStructuredDataResponse>>;
    upsertConfigurationRecipe(upsertRecipeRequest: UpsertRecipeRequest, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<UpsertSingleStructuredDataResponse>>;
    /**
     * [EXPERIMENTAL] UpsertRecipeComposer: Upsert a Recipe Composer. This creates or updates the data in Lusid.
     * Update or insert one Recipe Composer in a single scope. An item will be updated if it already exists  and inserted if it does not.                The response will return the successfully updated or inserted Recipe Composer or failure message if unsuccessful                It is important to always check to verify success (or failure).
     * @param upsertRecipeComposerRequest The Recipe Composer to update or insert
     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
     * @param reportProgress flag to report request and response progress.
     */
    upsertRecipeComposer(upsertRecipeComposerRequest: UpsertRecipeComposerRequest, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<UpsertSingleStructuredDataResponse>;
    upsertRecipeComposer(upsertRecipeComposerRequest: UpsertRecipeComposerRequest, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<UpsertSingleStructuredDataResponse>>;
    upsertRecipeComposer(upsertRecipeComposerRequest: UpsertRecipeComposerRequest, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<UpsertSingleStructuredDataResponse>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationRecipeService, [null, { optional: true; }, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationRecipeService>;
}