import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from '@angular/common/http';
import { Observable } from 'rxjs';
import { CreateDataTypeRequest } from '../model/createDataTypeRequest';
import { DataType } from '../model/dataType';
import { DeletedEntityResponse } from '../model/deletedEntityResponse';
import { FieldValue } from '../model/fieldValue';
import { PagedResourceListOfDataTypeSummary } from '../model/pagedResourceListOfDataTypeSummary';
import { ResourceListOfDataType } from '../model/resourceListOfDataType';
import { ResourceListOfIUnitDefinitionDto } from '../model/resourceListOfIUnitDefinitionDto';
import { UpdateDataTypeRequest } from '../model/updateDataTypeRequest';
import { UpdateReferenceDataRequest } from '../model/updateReferenceDataRequest';
import { Configuration } from '../configuration';
import * as i0 from "@angular/core";
export interface CreateDataTypeRequestParams {
    /** The definition of the new data type */
    createDataTypeRequest?: CreateDataTypeRequest;
}
export interface DeleteDataTypeRequestParams {
    /** The scope of the data type */
    scope: string;
    /** The code of the data type */
    code: string;
}
export interface GetDataTypeRequestParams {
    /** The scope of the data type */
    scope: string;
    /** The code of the data type */
    code: string;
    /** The asAt datetime at which to retrieve the data type definition. Defaults to              return the latest version of the instrument definition if not specified. */
    asAt?: string;
}
export interface GetUnitsFromDataTypeRequestParams {
    /** The scope of the data type */
    scope: string;
    /** The code of the data type */
    code: string;
    /** One or more unit identifiers for which the definition is being requested */
    units?: Array<string>;
    /** Optional. Expression to filter the result set.               For example, to filter on the Schema, use \&quot;schema eq \&#39;string\&#39;\&quot;              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid. */
    filter?: string;
    /** Optional. The as at of the requested data type */
    asAt?: string;
}
export interface ListDataTypeSummariesRequestParams {
    /** The asAt datetime at which to list the data type summaries. Defaults to returning the latest version               of each summary if not specified. */
    asAt?: string;
    /** The pagination token to use to continue listing data type summaries. This  value is returned from the previous call. If a pagination token is provided, the filter, sortBy  and asAt fields must not have changed since the original request. */
    page?: string;
    /** When paginating, limit the results to this number. Defaults to 100 if not specified. */
    limit?: number;
    /** Optional. Expression to filter the result set.                For example, to filter on the Scope, use \&quot;id.scope eq \&#39;myscope\&#39;\&quot;, to filter on Schema, use \&quot;schema eq \&#39;string\&#39;\&quot;,               to filter on AcceptableValues use \&quot;acceptableValues any (~ eq \&#39;value\&#39;)\&quot;               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid. */
    filter?: string;
    /** A list of field names to sort by, each suffixed by \&quot; ASC\&quot; or \&quot; DESC\&quot; */
    sortBy?: Array<string>;
}
export interface ListDataTypesRequestParams {
    /** The requested scope of the data types */
    scope: string;
    /** The as at of the requested data types */
    asAt?: string;
    /** Whether to additionally include those data types in the \&quot;system\&quot; scope */
    includeSystem?: boolean;
    /** Optional. Order the results by these fields. Use use the \&#39;-\&#39; sign to denote descending order e.g. -MyFieldName */
    sortBy?: Array<string>;
    /** Optional. When paginating, limit the number of returned results to this many. */
    limit?: number;
    /** Optional. Expression to filter the result set.              For example, to filter on the Display Name, use \&quot;displayName eq \&#39;string\&#39;\&quot;              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid. */
    filter?: string;
}
export interface UpdateDataTypeRequestParams {
    /** The scope of the data type */
    scope: string;
    /** The code of the data type */
    code: string;
    /** The updated definition of the data type */
    updateDataTypeRequest: UpdateDataTypeRequest;
}
export interface UpdateReferenceDataRequestParams {
    /** The scope of the data type */
    scope: string;
    /** The code of the data type */
    code: string;
    /** The updated reference data */
    updateReferenceDataRequest: UpdateReferenceDataRequest;
}
export interface UpdateReferenceValuesRequestParams {
    /** The scope of the data type */
    scope: string;
    /** The code of the data type */
    code: string;
    /** The updated reference values */
    fieldValue: Array<FieldValue>;
}
export declare class DataTypesService {
    protected httpClient: HttpClient;
    protected basePath: string;
    defaultHeaders: HttpHeaders;
    configuration: Configuration;
    encoder: HttpParameterCodec;
    constructor(httpClient: HttpClient, basePath: string | string[], configuration: Configuration);
    private addToHttpParams;
    private addToHttpParamsRecursive;
    /**
     * [EARLY ACCESS] CreateDataType: Create data type definition
     * Create a new data type definition    Data types cannot be created in either the \&quot;default\&quot; or \&quot;system\&quot; scopes.
     * @param requestParameters
     * @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.
     */
    createDataType(requestParameters?: CreateDataTypeRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<DataType>;
    createDataType(requestParameters?: CreateDataTypeRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<DataType>>;
    createDataType(requestParameters?: CreateDataTypeRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<DataType>>;
    /**
     * DeleteDataType: Delete a data type definition.
     * Delete an existing data type definition.    Data types cannot be deleted in either the \&quot;default\&quot; or \&quot;system\&quot; scopes, scopes beginning with \&quot;LUSID-\&quot;,  or data types that are in use on a property definition.
     * @param requestParameters
     * @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.
     */
    deleteDataType(requestParameters?: DeleteDataTypeRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<DeletedEntityResponse>;
    deleteDataType(requestParameters?: DeleteDataTypeRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<DeletedEntityResponse>>;
    deleteDataType(requestParameters?: DeleteDataTypeRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<DeletedEntityResponse>>;
    /**
     * GetDataType: Get data type definition
     * Get the definition of a specified data type
     * @param requestParameters
     * @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.
     */
    getDataType(requestParameters?: GetDataTypeRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<DataType>;
    getDataType(requestParameters?: GetDataTypeRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<DataType>>;
    getDataType(requestParameters?: GetDataTypeRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<DataType>>;
    /**
     * [EARLY ACCESS] GetUnitsFromDataType: Get units from data type
     * Get the definitions of the specified units associated bound to a specific data type
     * @param requestParameters
     * @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.
     */
    getUnitsFromDataType(requestParameters?: GetUnitsFromDataTypeRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<ResourceListOfIUnitDefinitionDto>;
    getUnitsFromDataType(requestParameters?: GetUnitsFromDataTypeRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<ResourceListOfIUnitDefinitionDto>>;
    getUnitsFromDataType(requestParameters?: GetUnitsFromDataTypeRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<ResourceListOfIUnitDefinitionDto>>;
    /**
     * [EARLY ACCESS] ListDataTypeSummaries: List all data type summaries, without the reference data
     * List all data type summaries
     * @param requestParameters
     * @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.
     */
    listDataTypeSummaries(requestParameters?: ListDataTypeSummariesRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<PagedResourceListOfDataTypeSummary>;
    listDataTypeSummaries(requestParameters?: ListDataTypeSummariesRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<PagedResourceListOfDataTypeSummary>>;
    listDataTypeSummaries(requestParameters?: ListDataTypeSummariesRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<PagedResourceListOfDataTypeSummary>>;
    /**
     * ListDataTypes: List data types
     * List all data types in a specified scope
     * @param requestParameters
     * @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.
     */
    listDataTypes(requestParameters?: ListDataTypesRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<ResourceListOfDataType>;
    listDataTypes(requestParameters?: ListDataTypesRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<ResourceListOfDataType>>;
    listDataTypes(requestParameters?: ListDataTypesRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<ResourceListOfDataType>>;
    /**
     * [EARLY ACCESS] UpdateDataType: Update data type definition
     * Update the definition of the specified existing data type    Not all elements within a data type definition are modifiable due to the potential implications for data  already stored against the types
     * @param requestParameters
     * @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.
     */
    updateDataType(requestParameters?: UpdateDataTypeRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<DataType>;
    updateDataType(requestParameters?: UpdateDataTypeRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<DataType>>;
    updateDataType(requestParameters?: UpdateDataTypeRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<DataType>>;
    /**
     * [EARLY ACCESS] UpdateReferenceData: Update all reference data on a data type, includes the reference values, the field definitions, field values
     * Replaces the whole set of reference data
     * @param requestParameters
     * @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.
     */
    updateReferenceData(requestParameters?: UpdateReferenceDataRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<DataType>;
    updateReferenceData(requestParameters?: UpdateReferenceDataRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<DataType>>;
    updateReferenceData(requestParameters?: UpdateReferenceDataRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<DataType>>;
    /**
     * [EARLY ACCESS] UpdateReferenceValues: Update reference data on a data type
     * Replaces the whole set of reference values
     * @param requestParameters
     * @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.
     */
    updateReferenceValues(requestParameters?: UpdateReferenceValuesRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<DataType>;
    updateReferenceValues(requestParameters?: UpdateReferenceValuesRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<DataType>>;
    updateReferenceValues(requestParameters?: UpdateReferenceValuesRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<DataType>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DataTypesService, [null, { optional: true; }, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DataTypesService>;
}