@finbourne/lusid-sdk-angular18

import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from '@angular/common/http'; import { Observable } from 'rxjs'; import { BatchUpdateUserReviewForComparisonResultRequest } from '../model/batchUpdateUserReviewForComparisonResultRequest'; import { BatchUpdateUserReviewForComparisonResultResponse } from '../model/batchUpdateUserReviewForComparisonResultResponse'; import { CreateGroupReconciliationComparisonRulesetRequest } from '../model/createGroupReconciliationComparisonRulesetRequest'; import { CreateGroupReconciliationDefinitionRequest } from '../model/createGroupReconciliationDefinitionRequest'; import { DeletedEntityResponse } from '../model/deletedEntityResponse'; import { GroupReconciliationComparisonResult } from '../model/groupReconciliationComparisonResult'; import { GroupReconciliationComparisonRuleset } from '../model/groupReconciliationComparisonRuleset'; import { GroupReconciliationDefinition } from '../model/groupReconciliationDefinition'; import { GroupReconciliationRunRequest } from '../model/groupReconciliationRunRequest'; import { GroupReconciliationRunResponse } from '../model/groupReconciliationRunResponse'; import { PagedResourceListOfGroupReconciliationComparisonResult } from '../model/pagedResourceListOfGroupReconciliationComparisonResult'; import { PagedResourceListOfGroupReconciliationComparisonRuleset } from '../model/pagedResourceListOfGroupReconciliationComparisonRuleset'; import { PagedResourceListOfGroupReconciliationDefinition } from '../model/pagedResourceListOfGroupReconciliationDefinition'; import { UpdateGroupReconciliationComparisonRulesetRequest } from '../model/updateGroupReconciliationComparisonRulesetRequest'; import { UpdateGroupReconciliationDefinitionRequest } from '../model/updateGroupReconciliationDefinitionRequest'; import { Configuration } from '../configuration'; import * as i0 from "@angular/core"; export interface BatchUpdateComparisonResultsRequestParams { /** Shared Scope of the GroupReconciliationDefinition and GroupReconciliationComparisonResults. */ scope: string; /** GroupReconciliationDefinitionId code. */ code: string; /** A collection of the comparison result Ids and their user review entries to be added or removed. Single request contains resultId, break code/match key/comment to add and break code/match key/comment to remove by added timestamp. */ batchUpdateUserReviewForComparisonResultRequest: Array<BatchUpdateUserReviewForComparisonResultRequest>; /** Defines whether the request should fail if at least one of the entries is failed to update or process all the entries regardless and return collections of successful and failed updates. \"Partial\" (default) | \"Atomic\". */ successMode?: string; } export interface CreateComparisonRulesetRequestParams { /** The request containing the details of the ruleset */ createGroupReconciliationComparisonRulesetRequest?: CreateGroupReconciliationComparisonRulesetRequest; } export interface CreateGroupReconciliationDefinitionRequestParams { /** The definition Group Reconciliation Definition details */ createGroupReconciliationDefinitionRequest?: CreateGroupReconciliationDefinitionRequest; } export interface DeleteComparisonRulesetRequestParams { /** The scope of the specified comparison ruleset. */ scope: string; /** The code of the specified comparison ruleset. Together with the domain and scope this uniquely identifies the reconciliation comparison ruleset. */ code: string; } export interface DeleteGroupReconciliationDefinitionRequestParams { /** The scope of the group reconciliation definition to delete. */ scope: string; /** The code of the group reconciliation definition to delete. Together with the scope this uniquely identifies the group reconciliation definition to delete. */ code: string; } export interface GetComparisonResultRequestParams { /** The scope of the specified comparison result and its related reconciliation definition. */ scope: string; /** The code of the reconciliation definition that was used to produce the reconciliation result. */ code: string; /** The code of the specified reconciliation result. Together with the domain and scope this uniquely identifies the reconciliation comparison result. This value is also the same as the computed result hash based on property values. */ resultId: string; /** The asAt datetime at which to retrieve the comparison result definition. Defaults to return the latest version if not specified. */ asAt?: string; } export interface GetComparisonRulesetRequestParams { /** The scope of the specified comparison ruleset. */ scope: string; /** The code of the specified comparison ruleset. Together with the domain and scope this uniquely identifies the reconciliation comparison ruleset. */ code: string; /** The asAt datetime at which to retrieve the comparison ruleset definition. Defaults to return the latest version of the definition if not specified. */ asAt?: string; } export interface GetGroupReconciliationDefinitionRequestParams { /** The scope of the group reconciliation definition to retrieve. */ scope: string; /** The code of the group reconciliation definition to retrieve. Together with the scope this uniquely identifies the group reconciliation definition. */ code: string; /** The effective datetime or cut label at which to retrieve the group reconciliation definition. Defaults to the current LUSID system datetime if not specified. */ effectiveAt?: string; /** The asAt datetime at which to retrieve the group reconciliation definition. Defaults to return the latest version of the portfolio group definition if not specified. */ asAt?: string; } export interface ListComparisonResultsRequestParams { /** The asAt datetime at which to retrieve the comparison results. Defaults to return the latest version of the comparison results if not specified. */ asAt?: string; /** The pagination token to use to continue listing comparison results from a previous call to list comparison results. This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields must not have changed since the original request. */ page?: string; /** A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\". */ sortBy?: Array<string>; /** When paginating, limit the number of returned results to this many per page. */ limit?: number; /** Expression to filter the result set. Read more about filtering results from LUSID here: https://support.lusid.com/filtering-results-from-lusid. */ filter?: string; } export interface ListComparisonRulesetsRequestParams { /** The asAt datetime at which to retrieve the comparison rulesets. Defaults to return the latest version of the comparison rulesets if not specified. */ asAt?: string; /** The pagination token to use to continue listing comparison rulesets from a previous call to list comparison rulesets. This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields must not have changed since the original request. */ page?: string; /** A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\" */ sortBy?: Array<string>; /** When paginating, limit the number of returned results to this many per page. */ limit?: number; /** Expression to filter the result set. Read more about filtering results from LUSID here: https://support.lusid.com/filtering-results-from-lusid. */ filter?: string; } export interface ListGroupReconciliationDefinitionsRequestParams { /** The effective datetime or cut label at which to list the group reconciliation definitions. Defaults to the current LUSID system datetime if not specified. */ effectiveAt?: string; /** The asAt datetime at which to list the group reconciliation definitions. Defaults to return the latest version of each group reconciliation definition if not specified. */ asAt?: string; /** The pagination token to use to continue listing group reconciliation definitions from a previous call to list group reconciliation definitions. This value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, sortBy and asAt fields must not have changed since the original request. */ page?: string; /** When paginating, limit the number of returned results to this many. Defaults to no limit if not specified. */ limit?: number; /** Expression to filter the result set. For example, to filter on the Display Name, use \"displayName eq \'string\'\" 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 \" ASC\" or \" DESC\" */ sortBy?: Array<string>; } export interface RunReconciliationRequestParams { /** The scope of the group reconciliation definition to use for the reconciliation. */ scope: string; /** The code of the group reconciliation definition to use for the reconciliation. */ code: string; /** */ groupReconciliationRunRequest?: GroupReconciliationRunRequest; } export interface UpdateComparisonRulesetRequestParams { /** The scope of the specified comparison ruleset. */ scope: string; /** The code of the specified comparison ruleset. Together with the domain and scope this uniquely identifies the reconciliation comparison ruleset. */ code: string; /** The request containing the updated details of the ruleset */ updateGroupReconciliationComparisonRulesetRequest?: UpdateGroupReconciliationComparisonRulesetRequest; } export interface UpdateGroupReconciliationDefinitionRequestParams { /** The scope of the group reconciliation definition to update the details for. */ scope: string; /** The code of the group reconciliation definition to update the details for. Together with the scope this uniquely identifies the group reconciliation definition. */ code: string; /** The updated group reconciliation definition. */ updateGroupReconciliationDefinitionRequest?: UpdateGroupReconciliationDefinitionRequest; } export declare class GroupReconciliationsService { protected httpClient: HttpClient; protected basePath: string; defaultHeaders: HttpHeaders; configuration: Configuration; encoder: HttpParameterCodec; constructor(httpClient: HttpClient, basePath: string | string[], configuration: Configuration); private addToHttpParams; private addToHttpParamsRecursive; /** * [EXPERIMENTAL] BatchUpdateComparisonResults: Add User Review entries for a range of comparison results related to a specific GroupReconciliationDefinition. * Allows to update multiple Group Reconciliation Comparison Results related to the same definition specified by the Finbourne.Identifiers.Abstractions.Scope and Finbourne.Identifiers.Abstractions.Code. Updates User Review with new entries and sets the relevant Review Status. Supports partial success when all the entries that haven\'t passed validation or are not related to the definition will be returned with respectful error details. * @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. */ batchUpdateComparisonResults(requestParameters?: BatchUpdateComparisonResultsRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<BatchUpdateUserReviewForComparisonResultResponse>; batchUpdateComparisonResults(requestParameters?: BatchUpdateComparisonResultsRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<BatchUpdateUserReviewForComparisonResultResponse>>; batchUpdateComparisonResults(requestParameters?: BatchUpdateComparisonResultsRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<BatchUpdateUserReviewForComparisonResultResponse>>; /** * [EXPERIMENTAL] CreateComparisonRuleset: Create a Group Reconciliation Comparison Ruleset * Creates a set of core and aggregate rules to be run for a group reconciliation * @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. */ createComparisonRuleset(requestParameters?: CreateComparisonRulesetRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<GroupReconciliationComparisonRuleset>; createComparisonRuleset(requestParameters?: CreateComparisonRulesetRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<GroupReconciliationComparisonRuleset>>; createComparisonRuleset(requestParameters?: CreateComparisonRulesetRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<GroupReconciliationComparisonRuleset>>; /** * [EXPERIMENTAL] CreateGroupReconciliationDefinition: Create Group Reconciliation Definition * Creates a Group Reconciliation 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. */ createGroupReconciliationDefinition(requestParameters?: CreateGroupReconciliationDefinitionRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<GroupReconciliationDefinition>; createGroupReconciliationDefinition(requestParameters?: CreateGroupReconciliationDefinitionRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<GroupReconciliationDefinition>>; createGroupReconciliationDefinition(requestParameters?: CreateGroupReconciliationDefinitionRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<GroupReconciliationDefinition>>; /** * [EXPERIMENTAL] DeleteComparisonRuleset: Deletes a particular Group Reconciliation Comparison Ruleset * The deletion will take effect from the reconciliation comparison ruleset deletion datetime. i.e. will no longer exist at any asAt datetime after the asAt datetime of deletion. * @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. */ deleteComparisonRuleset(requestParameters?: DeleteComparisonRulesetRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<DeletedEntityResponse>; deleteComparisonRuleset(requestParameters?: DeleteComparisonRulesetRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<DeletedEntityResponse>>; deleteComparisonRuleset(requestParameters?: DeleteComparisonRulesetRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<DeletedEntityResponse>>; /** * [EXPERIMENTAL] DeleteGroupReconciliationDefinition: Delete Group Reconciliation Definition * Delete the group reconciliation 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. */ deleteGroupReconciliationDefinition(requestParameters?: DeleteGroupReconciliationDefinitionRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<DeletedEntityResponse>; deleteGroupReconciliationDefinition(requestParameters?: DeleteGroupReconciliationDefinitionRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<DeletedEntityResponse>>; deleteGroupReconciliationDefinition(requestParameters?: DeleteGroupReconciliationDefinitionRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<DeletedEntityResponse>>; /** * [EXPERIMENTAL] GetComparisonResult: Get a single Group Reconciliation Comparison Result by scope and code. * Retrieves one Group Reconciliation Comparison Result by scope and code with the prior validation that its related reconciliation definition exists. * @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. */ getComparisonResult(requestParameters?: GetComparisonResultRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<GroupReconciliationComparisonResult>; getComparisonResult(requestParameters?: GetComparisonResultRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<GroupReconciliationComparisonResult>>; getComparisonResult(requestParameters?: GetComparisonResultRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<GroupReconciliationComparisonResult>>; /** * [EXPERIMENTAL] GetComparisonRuleset: Get a single Group Reconciliation Comparison Ruleset by scope and code. * Retrieves one Group Reconciliation Comparison Ruleset by scope and code. * @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. */ getComparisonRuleset(requestParameters?: GetComparisonRulesetRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<GroupReconciliationComparisonRuleset>; getComparisonRuleset(requestParameters?: GetComparisonRulesetRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<GroupReconciliationComparisonRuleset>>; getComparisonRuleset(requestParameters?: GetComparisonRulesetRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<GroupReconciliationComparisonRuleset>>; /** * [EXPERIMENTAL] GetGroupReconciliationDefinition: Get group reconciliation definition * Retrieves a Group Reconciliation Definition by scope and code * @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. */ getGroupReconciliationDefinition(requestParameters?: GetGroupReconciliationDefinitionRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<GroupReconciliationDefinition>; getGroupReconciliationDefinition(requestParameters?: GetGroupReconciliationDefinitionRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<GroupReconciliationDefinition>>; getGroupReconciliationDefinition(requestParameters?: GetGroupReconciliationDefinitionRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<GroupReconciliationDefinition>>; /** * [EXPERIMENTAL] ListComparisonResults: Get a set of Group Reconciliation Comparison Results. * Retrieves all Group Reconciliation Comparison Results that fit the filter, in a specific order if sortBy is provided. Supports pagination. * @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. */ listComparisonResults(requestParameters?: ListComparisonResultsRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<PagedResourceListOfGroupReconciliationComparisonResult>; listComparisonResults(requestParameters?: ListComparisonResultsRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<PagedResourceListOfGroupReconciliationComparisonResult>>; listComparisonResults(requestParameters?: ListComparisonResultsRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<PagedResourceListOfGroupReconciliationComparisonResult>>; /** * [EXPERIMENTAL] ListComparisonRulesets: Get a set of Group Reconciliation Comparison Rulesets * Retrieves all Group Reconciliation Comparison Ruleset that fit the filter, in a specific order if sortBy is provided Supports pagination * @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. */ listComparisonRulesets(requestParameters?: ListComparisonRulesetsRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<PagedResourceListOfGroupReconciliationComparisonRuleset>; listComparisonRulesets(requestParameters?: ListComparisonRulesetsRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<PagedResourceListOfGroupReconciliationComparisonRuleset>>; listComparisonRulesets(requestParameters?: ListComparisonRulesetsRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<PagedResourceListOfGroupReconciliationComparisonRuleset>>; /** * [EXPERIMENTAL] ListGroupReconciliationDefinitions: List group reconciliation definitions * Lists Group Reconciliation Definitions matching any provided filter, limit and sorting rules * @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. */ listGroupReconciliationDefinitions(requestParameters?: ListGroupReconciliationDefinitionsRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<PagedResourceListOfGroupReconciliationDefinition>; listGroupReconciliationDefinitions(requestParameters?: ListGroupReconciliationDefinitionsRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<PagedResourceListOfGroupReconciliationDefinition>>; listGroupReconciliationDefinitions(requestParameters?: ListGroupReconciliationDefinitionsRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<PagedResourceListOfGroupReconciliationDefinition>>; /** * [EXPERIMENTAL] RunReconciliation: Runs a Group Reconciliation * Runs a Group Reconciliation using the definition specified by the Finbourne.Identifiers.Abstractions.Scope and Finbourne.Identifiers.Abstractions.Code Supports pagination. * @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. */ runReconciliation(requestParameters?: RunReconciliationRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<GroupReconciliationRunResponse>; runReconciliation(requestParameters?: RunReconciliationRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<GroupReconciliationRunResponse>>; runReconciliation(requestParameters?: RunReconciliationRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<GroupReconciliationRunResponse>>; /** * [EXPERIMENTAL] UpdateComparisonRuleset: Update Group Reconciliation Comparison Ruleset defined by scope and code * Overwrites an existing Group Reconciliation Comparison Ruleset Update request has the same required fields as Create apart from the Id * @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. */ updateComparisonRuleset(requestParameters?: UpdateComparisonRulesetRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<GroupReconciliationComparisonRuleset>; updateComparisonRuleset(requestParameters?: UpdateComparisonRulesetRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<GroupReconciliationComparisonRuleset>>; updateComparisonRuleset(requestParameters?: UpdateComparisonRulesetRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<GroupReconciliationComparisonRuleset>>; /** * [EXPERIMENTAL] UpdateGroupReconciliationDefinition: Update group reconciliation definition * Update the group reconciliation 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. */ updateGroupReconciliationDefinition(requestParameters?: UpdateGroupReconciliationDefinitionRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<GroupReconciliationDefinition>; updateGroupReconciliationDefinition(requestParameters?: UpdateGroupReconciliationDefinitionRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<GroupReconciliationDefinition>>; updateGroupReconciliationDefinition(requestParameters?: UpdateGroupReconciliationDefinitionRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<GroupReconciliationDefinition>>; static ɵfac: i0.ɵɵFactoryDeclaration<GroupReconciliationsService, [null, { optional: true; }, { optional: true; }]>; static ɵprov: i0.ɵɵInjectableDeclaration<GroupReconciliationsService>; }