import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from '@angular/common/http';
import { Observable } from 'rxjs';
import { Account } from '../model/account';
import { AccountProperties } from '../model/accountProperties';
import { AccountsUpsertResponse } from '../model/accountsUpsertResponse';
import { ChartOfAccounts } from '../model/chartOfAccounts';
import { ChartOfAccountsProperties } from '../model/chartOfAccountsProperties';
import { ChartOfAccountsRequest } from '../model/chartOfAccountsRequest';
import { CleardownModuleDetails } from '../model/cleardownModuleDetails';
import { CleardownModuleRequest } from '../model/cleardownModuleRequest';
import { CleardownModuleResponse } from '../model/cleardownModuleResponse';
import { CleardownModuleRule } from '../model/cleardownModuleRule';
import { CleardownModuleRulesUpdatedResponse } from '../model/cleardownModuleRulesUpdatedResponse';
import { DeleteAccountsResponse } from '../model/deleteAccountsResponse';
import { DeletedEntityResponse } from '../model/deletedEntityResponse';
import { GeneralLedgerProfileMapping } from '../model/generalLedgerProfileMapping';
import { GeneralLedgerProfileRequest } from '../model/generalLedgerProfileRequest';
import { GeneralLedgerProfileResponse } from '../model/generalLedgerProfileResponse';
import { Operation } from '../model/operation';
import { PagedResourceListOfAccount } from '../model/pagedResourceListOfAccount';
import { PagedResourceListOfChartOfAccounts } from '../model/pagedResourceListOfChartOfAccounts';
import { PagedResourceListOfCleardownModuleResponse } from '../model/pagedResourceListOfCleardownModuleResponse';
import { PagedResourceListOfCleardownModuleRule } from '../model/pagedResourceListOfCleardownModuleRule';
import { PagedResourceListOfGeneralLedgerProfileResponse } from '../model/pagedResourceListOfGeneralLedgerProfileResponse';
import { PagedResourceListOfPostingModuleResponse } from '../model/pagedResourceListOfPostingModuleResponse';
import { PagedResourceListOfPostingModuleRule } from '../model/pagedResourceListOfPostingModuleRule';
import { PostingModuleDetails } from '../model/postingModuleDetails';
import { PostingModuleRequest } from '../model/postingModuleRequest';
import { PostingModuleResponse } from '../model/postingModuleResponse';
import { PostingModuleRule } from '../model/postingModuleRule';
import { PostingModuleRulesUpdatedResponse } from '../model/postingModuleRulesUpdatedResponse';
import { Property } from '../model/property';
import { Configuration } from '../configuration';
import * as i0 from "@angular/core";
export declare class ChartOfAccountsService {
    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] CreateChartOfAccounts: Create a Chart of Accounts
     * Create the given Chart of Accounts.
     * @param scope The scope of the Chart of Accounts.
     * @param chartOfAccountsRequest The definition of the Chart of Accounts.
     * @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.
     */
    createChartOfAccounts(scope: string, chartOfAccountsRequest: ChartOfAccountsRequest, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<ChartOfAccounts>;
    createChartOfAccounts(scope: string, chartOfAccountsRequest: ChartOfAccountsRequest, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<ChartOfAccounts>>;
    createChartOfAccounts(scope: string, chartOfAccountsRequest: ChartOfAccountsRequest, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<ChartOfAccounts>>;
    /**
     * [EXPERIMENTAL] CreateCleardownModule: Create a Cleardown Module
     * Create the given Cleardown Module.
     * @param scope The scope of the Chart of Accounts.
     * @param code The code of the Chart of Accounts. Together with the scope this uniquely identifies the Chart of Accounts.
     * @param cleardownModuleRequest The definition of the Cleardown Module.
     * @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.
     */
    createCleardownModule(scope: string, code: string, cleardownModuleRequest: CleardownModuleRequest, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<CleardownModuleResponse>;
    createCleardownModule(scope: string, code: string, cleardownModuleRequest: CleardownModuleRequest, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<CleardownModuleResponse>>;
    createCleardownModule(scope: string, code: string, cleardownModuleRequest: CleardownModuleRequest, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<CleardownModuleResponse>>;
    /**
     * [EXPERIMENTAL] CreateGeneralLedgerProfile: Create a General Ledger Profile.
     * Create the given General Ledger profile.
     * @param scope The scope of the Chart of Accounts.
     * @param code The code of the Chart of Accounts.
     * @param generalLedgerProfileRequest The definition of the General Ledger Profile.
     * @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.
     */
    createGeneralLedgerProfile(scope: string, code: string, generalLedgerProfileRequest: GeneralLedgerProfileRequest, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<GeneralLedgerProfileResponse>;
    createGeneralLedgerProfile(scope: string, code: string, generalLedgerProfileRequest: GeneralLedgerProfileRequest, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<GeneralLedgerProfileResponse>>;
    createGeneralLedgerProfile(scope: string, code: string, generalLedgerProfileRequest: GeneralLedgerProfileRequest, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<GeneralLedgerProfileResponse>>;
    /**
     * [EXPERIMENTAL] CreatePostingModule: Create a Posting Module
     * Create the given Posting Module.
     * @param scope The scope of the Chart of Accounts.
     * @param code The code of the Chart of Accounts. Together with the scope this uniquely identifies the Chart of Accounts.
     * @param postingModuleRequest The definition of the Posting Module.
     * @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.
     */
    createPostingModule(scope: string, code: string, postingModuleRequest: PostingModuleRequest, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<PostingModuleResponse>;
    createPostingModule(scope: string, code: string, postingModuleRequest: PostingModuleRequest, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<PostingModuleResponse>>;
    createPostingModule(scope: string, code: string, postingModuleRequest: PostingModuleRequest, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<PostingModuleResponse>>;
    /**
     * [EXPERIMENTAL] DeleteAccounts: Soft or hard delete multiple accounts
     * Delete one or more account from the Chart of Accounts. Soft deletion marks the account as inactive  While the Hard deletion is deleting the account.  The maximum number of accounts that this method can delete per request is 2,000.
     * @param scope The scope of the Chart of Accounts.
     * @param code The code of the Chart of Accounts. Together with the scope this uniquely identifies              the Chart of Accounts.
     * @param requestBody The codes of the accounts to delete.
     * @param deleteMode The delete mode to use (defaults to \&#39;Soft\&#39;).
     * @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.
     */
    deleteAccounts(scope: string, code: string, requestBody: Array<string>, deleteMode?: 'Soft' | 'Hard', observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<DeleteAccountsResponse>;
    deleteAccounts(scope: string, code: string, requestBody: Array<string>, deleteMode?: 'Soft' | 'Hard', observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<DeleteAccountsResponse>>;
    deleteAccounts(scope: string, code: string, requestBody: Array<string>, deleteMode?: 'Soft' | 'Hard', observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<DeleteAccountsResponse>>;
    /**
     * [EXPERIMENTAL] DeleteChartOfAccounts: Delete a Chart of Accounts
     * Delete the given Chart of Accounts.
     * @param scope The scope of the Chart of Accounts to be deleted.
     * @param code The code of the Chart of Accounts to be deleted. Together with the scope this uniquely identifies the Chart of Accounts.
     * @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.
     */
    deleteChartOfAccounts(scope: string, code: string, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<DeletedEntityResponse>;
    deleteChartOfAccounts(scope: string, code: string, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<DeletedEntityResponse>>;
    deleteChartOfAccounts(scope: string, code: string, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<DeletedEntityResponse>>;
    /**
     * [EXPERIMENTAL] DeleteCleardownModule: Delete a Cleardown Module.
     * Delete the given Cleardown Module.
     * @param scope The scope of the Chart of Accounts.
     * @param code The code of the Chart of Accounts. Together with the scope this uniquely identifies the Chart of Accounts.
     * @param cleardownModuleCode The code of the Cleardown Module to be deleted.
     * @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.
     */
    deleteCleardownModule(scope: string, code: string, cleardownModuleCode: string, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<DeletedEntityResponse>;
    deleteCleardownModule(scope: string, code: string, cleardownModuleCode: string, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<DeletedEntityResponse>>;
    deleteCleardownModule(scope: string, code: string, cleardownModuleCode: string, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<DeletedEntityResponse>>;
    /**
     * [EXPERIMENTAL] DeleteGeneralLedgerProfile: Delete a General Ledger Profile.
     * Delete the given General Ledger Profile.
     * @param scope The scope of the Chart of Accounts for the General Ledger Profile.
     * @param code The code of the Chart of Accounts for the General Ledger Profile.
     * @param generalLedgerProfileCode The Code of the General Ledger Profile.
     * @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.
     */
    deleteGeneralLedgerProfile(scope: string, code: string, generalLedgerProfileCode: string, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<DeletedEntityResponse>;
    deleteGeneralLedgerProfile(scope: string, code: string, generalLedgerProfileCode: string, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<DeletedEntityResponse>>;
    deleteGeneralLedgerProfile(scope: string, code: string, generalLedgerProfileCode: string, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<DeletedEntityResponse>>;
    /**
     * [EXPERIMENTAL] DeletePostingModule: Delete a Posting Module.
     * Delete the given Posting Module.
     * @param scope The scope of the Chart of Accounts.
     * @param code The code of the Chart of Accounts. Together with the scope this uniquely identifies the Chart of Accounts.
     * @param postingModuleCode The code of the Posting Module to be deleted.
     * @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.
     */
    deletePostingModule(scope: string, code: string, postingModuleCode: string, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<DeletedEntityResponse>;
    deletePostingModule(scope: string, code: string, postingModuleCode: string, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<DeletedEntityResponse>>;
    deletePostingModule(scope: string, code: string, postingModuleCode: string, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<DeletedEntityResponse>>;
    /**
     * [EXPERIMENTAL] GetAccount: Get Account
     * Retrieve the definition of a particular Account which is part of a Chart of Accounts.
     * @param scope The scope of the Chart of Accounts.
     * @param code The code of the Chart of Accounts. Together with the scope this uniquely identifies the Chart of Accounts.
     * @param accountCode The code of the Account.
     * @param effectiveAt The effective datetime or cut label at which to retrieve the Account properties. Defaults to the current LUSID system datetime if not specified.
     * @param asAt The asAt datetime at which to retrieve the Account definition. Defaults to returning the latest version of the Account definition if not specified.
     * @param propertyKeys A list of property keys from the \&#39;Account\&#39; domain to decorate onto the Account.              These must take the format {domain}/{scope}/{code}, for example \&#39;Account/Manager/Id\&#39;. If not provided will return all the entitled properties for that Account.
     * @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.
     */
    getAccount(scope: string, code: string, accountCode: string, effectiveAt?: string, asAt?: string, propertyKeys?: Array<string>, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<Account>;
    getAccount(scope: string, code: string, accountCode: string, effectiveAt?: string, asAt?: string, propertyKeys?: Array<string>, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<Account>>;
    getAccount(scope: string, code: string, accountCode: string, effectiveAt?: string, asAt?: string, propertyKeys?: Array<string>, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<Account>>;
    /**
     * [EXPERIMENTAL] GetChartOfAccounts: Get ChartOfAccounts
     * Retrieve the definition of a particular Chart of Accounts.
     * @param scope The scope of the Chart of Accounts.
     * @param code The code of the Chart of Accounts. Together with the scope this uniquely identifies the Chart of Accounts.
     * @param effectiveAt The effective datetime or cut label at which to retrieve the Chart of Accounts properties. Defaults to the current LUSID system datetime if not specified.
     * @param asAt The asAt datetime at which to retrieve the Chart of Accounts definition. Defaults to returning the latest version of the Chart of Accounts definition if not specified.
     * @param propertyKeys A list of property keys from the \&#39;ChartOfAccounts\&#39; domain to decorate onto the Chart of Accounts.              These must take the format {domain}/{scope}/{code}, for example \&#39;ChartOfAccounts/Manager/Id\&#39;. If no properties are specified, then no properties will be returned.
     * @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.
     */
    getChartOfAccounts(scope: string, code: string, effectiveAt?: string, asAt?: string, propertyKeys?: Array<string>, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<ChartOfAccounts>;
    getChartOfAccounts(scope: string, code: string, effectiveAt?: string, asAt?: string, propertyKeys?: Array<string>, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<ChartOfAccounts>>;
    getChartOfAccounts(scope: string, code: string, effectiveAt?: string, asAt?: string, propertyKeys?: Array<string>, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<ChartOfAccounts>>;
    /**
     * [EXPERIMENTAL] GetCleardownModule: Get a Cleardown Module
     * Retrieve the definition of a Cleardown Module complete with its rules.
     * @param scope The scope of the Chart of Accounts.
     * @param code The code of the Chart of Accounts. Together with the scope this uniquely identifies the Chart of Accounts.
     * @param cleardownModuleCode The code of the Cleardown Module.
     * @param asAt The asAt datetime at which to retrieve the Cleardown Module. Defaults to return the latest version of the Cleardown Module 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.
     */
    getCleardownModule(scope: string, code: string, cleardownModuleCode: string, asAt?: string, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<CleardownModuleResponse>;
    getCleardownModule(scope: string, code: string, cleardownModuleCode: string, asAt?: string, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<CleardownModuleResponse>>;
    getCleardownModule(scope: string, code: string, cleardownModuleCode: string, asAt?: string, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<CleardownModuleResponse>>;
    /**
     * [EXPERIMENTAL] GetGeneralLedgerProfile: Get a General Ledger Profile.
     * Get the given General Ledger Profile.
     * @param scope The scope of the Chart of Accounts for the General Ledger Profile.
     * @param code The code of the Chart of Accounts for the General Ledger Profile.
     * @param generalLedgerProfileCode The General Ledger Profile Code of the General Ledger Profile.
     * @param asAt The asAt datetime at which to retrieve the General Ledger Profile. Defaults to return the latest version of the General Ledger Profile 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.
     */
    getGeneralLedgerProfile(scope: string, code: string, generalLedgerProfileCode: string, asAt?: string, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<GeneralLedgerProfileResponse>;
    getGeneralLedgerProfile(scope: string, code: string, generalLedgerProfileCode: string, asAt?: string, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<GeneralLedgerProfileResponse>>;
    getGeneralLedgerProfile(scope: string, code: string, generalLedgerProfileCode: string, asAt?: string, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<GeneralLedgerProfileResponse>>;
    /**
     * [EXPERIMENTAL] GetPostingModule: Get a Posting Module
     * Retrieve the definition of a Posting Module complete with its rules.
     * @param scope The scope of the Chart of Accounts.
     * @param code The code of the Chart of Accounts. Together with the scope this uniquely identifies the Chart of Accounts.
     * @param postingModuleCode The code of the Posting Module.
     * @param asAt The asAt datetime at which to retrieve the Posting Module. Defaults to return the latest version of the Posting Module 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.
     */
    getPostingModule(scope: string, code: string, postingModuleCode: string, asAt?: string, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<PostingModuleResponse>;
    getPostingModule(scope: string, code: string, postingModuleCode: string, asAt?: string, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<PostingModuleResponse>>;
    getPostingModule(scope: string, code: string, postingModuleCode: string, asAt?: string, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<PostingModuleResponse>>;
    /**
     * [EXPERIMENTAL] ListAccounts: List Accounts
     * List the accounts in a Chart of Accounts
     * @param scope The scope of the Chart of Accounts.
     * @param code The code of the Chart of Accounts. Together with the scope this uniquely identifies              the Chart of Accounts.
     * @param effectiveAt The effective datetime or cut label at which to list the TimeVariant properties decorated on Accounts. Defaults to the current LUSID              system datetime if not specified.
     * @param asAt The asAt datetime at which to retrieve the Accounts. Defaults to              returning the latest version if not specified.
     * @param page The pagination token to use to continue listing charts of accounts; this              value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt              and asAt fields must not have changed since the original request.
     * @param limit When paginating, limit the results to this number. Defaults to 100 if not specified.
     * @param filter Expression to filter the results.              For example, to filter on the Account type, specify \&quot;code eq \&#39;001\&#39;\&quot;. For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.
     * @param propertyKeys A list of property keys from the \&#39;Account\&#39; domain to decorate onto the Account.              These must have the format {domain}/{scope}/{code}, for example \&#39;Account/system/Name\&#39;.
     * @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.
     */
    listAccounts(scope: string, code: string, effectiveAt?: string, asAt?: string, page?: string, limit?: number, filter?: string, propertyKeys?: Array<string>, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<PagedResourceListOfAccount>;
    listAccounts(scope: string, code: string, effectiveAt?: string, asAt?: string, page?: string, limit?: number, filter?: string, propertyKeys?: Array<string>, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<PagedResourceListOfAccount>>;
    listAccounts(scope: string, code: string, effectiveAt?: string, asAt?: string, page?: string, limit?: number, filter?: string, propertyKeys?: Array<string>, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<PagedResourceListOfAccount>>;
    /**
     * [EXPERIMENTAL] ListChartsOfAccounts: List Charts of Accounts
     * List all the Charts of Accounts matching particular criteria.
     * @param effectiveAt The effective datetime or cut label at which to list the TimeVariant properties for the Chart Of Accounts. Defaults to the current LUSID              system datetime if not specified.
     * @param asAt The asAt datetime at which to list the charts of accounts. Defaults to returning the latest version              of each Chart of Accounts if not specified.
     * @param page The pagination token to use to continue listing charts of accounts; this              value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt              and asAt fields must not have changed since the original request.
     * @param limit When paginating, limit the results to this number. Defaults to 100 if not specified.
     * @param filter Expression to filter the results.              For example, to filter on the Chart of Accounts type, specify \&quot;id.Code eq \&#39;001\&#39;\&quot;. For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.
     * @param sortBy A list of field names or properties to sort by, each suffixed by \&quot; ASC\&quot; or \&quot; DESC\&quot;.
     * @param propertyKeys A list of property keys from the \&#39;ChartOfAccounts\&#39; domain to decorate onto each Chart of Accounts.              These must take the format {domain}/{scope}/{code}, for example \&#39;ChartOfAccounts/Manager/Id\&#39;.
     * @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.
     */
    listChartsOfAccounts(effectiveAt?: string, asAt?: string, page?: string, limit?: number, filter?: string, sortBy?: Array<string>, propertyKeys?: Array<string>, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<PagedResourceListOfChartOfAccounts>;
    listChartsOfAccounts(effectiveAt?: string, asAt?: string, page?: string, limit?: number, filter?: string, sortBy?: Array<string>, propertyKeys?: Array<string>, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<PagedResourceListOfChartOfAccounts>>;
    listChartsOfAccounts(effectiveAt?: string, asAt?: string, page?: string, limit?: number, filter?: string, sortBy?: Array<string>, propertyKeys?: Array<string>, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<PagedResourceListOfChartOfAccounts>>;
    /**
     * [EXPERIMENTAL] ListCleardownModuleRules: List Cleardown Module Rules
     * List the Rules in a Cleardown Module
     * @param scope The scope of the Chart of Accounts.
     * @param code The code of the Chart of Accounts. Together with the scope this uniquely identifies the Chart of Accounts.
     * @param cleardownModuleCode The code of the cleardown module.
     * @param asAt The asAt datetime at which to retrieve the instrument. Defaults to              returning the latest version if not specified.
     * @param page The pagination token to use to continue listing cleardown module rules; this              value is returned from the previous call. If a pagination token is provided, the filter              and asAt fields must not have changed since the original request.
     * @param limit When paginating, limit the results to this number. Defaults to 100 if not specified.
     * @param filter Expression to filter the results.              For example, to filter on the rule id, specify \&quot;ruleId eq \&#39;rule 1\&#39;\&quot;. For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.
     * @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.
     */
    listCleardownModuleRules(scope: string, code: string, cleardownModuleCode: string, asAt?: string, page?: string, limit?: number, filter?: string, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<PagedResourceListOfCleardownModuleRule>;
    listCleardownModuleRules(scope: string, code: string, cleardownModuleCode: string, asAt?: string, page?: string, limit?: number, filter?: string, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<PagedResourceListOfCleardownModuleRule>>;
    listCleardownModuleRules(scope: string, code: string, cleardownModuleCode: string, asAt?: string, page?: string, limit?: number, filter?: string, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<PagedResourceListOfCleardownModuleRule>>;
    /**
     * [EXPERIMENTAL] ListCleardownModules: List Cleardown Modules
     * List all the Cleardown Modules matching particular criteria.
     * @param scope The scope of the Chart of Accounts.
     * @param code The code of the Chart of Accounts. Together with the scope this uniquely identifies the Chart of Accounts.
     * @param asAt The asAt datetime at which to list the Cleardown Module. Defaults to returning the latest version              of each Cleardown Module if not specified.
     * @param page The pagination token to use to continue listing Cleardown Modules; this              value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt              and asAt fields must not have changed since the original request.
     * @param limit When paginating, limit the results to this number. Defaults to 100 if not specified.
     * @param filter Expression to filter the results.              For example, to filter on the Cleardown Module status, specify \&quot;status eq \&#39;Active\&#39;\&quot;. For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.
     * @param sortBy A list of field names or properties to sort by, each suffixed by \&quot; ASC\&quot; or \&quot; DESC\&quot;.
     * @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.
     */
    listCleardownModules(scope: string, code: string, asAt?: string, page?: string, limit?: number, filter?: string, sortBy?: Array<string>, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<PagedResourceListOfCleardownModuleResponse>;
    listCleardownModules(scope: string, code: string, asAt?: string, page?: string, limit?: number, filter?: string, sortBy?: Array<string>, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<PagedResourceListOfCleardownModuleResponse>>;
    listCleardownModules(scope: string, code: string, asAt?: string, page?: string, limit?: number, filter?: string, sortBy?: Array<string>, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<PagedResourceListOfCleardownModuleResponse>>;
    /**
     * [EXPERIMENTAL] ListGeneralLedgerProfiles: List General Ledger Profiles.
     * List all the General Ledger profiles matching particular criteria.
     * @param scope The scope of the Chart of Accounts
     * @param code The code of the Chart of Accounts
     * @param asAt The asAt datetime at which to list the General Ledger Profiles. Defaults to returning the latest version of each General Ledger Profile if not specified.
     * @param page The pagination token to use to continue listing General Ledger Profiles; this              value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt              and asAt fields must not have changed since the original request.
     * @param limit When paginating, limit the results to this number. Defaults to 100 if not specified.
     * @param filter Expression to filter the results.              For example, to filter on the General Ledger profiles type, specify \&quot;type eq \&#39;PeriodBoundary\&#39;\&quot;. For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.
     * @param sortBy A list of field names or properties to sort by, each suffixed by \&quot; ASC\&quot; or \&quot; DESC\&quot;.
     * @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.
     */
    listGeneralLedgerProfiles(scope: string, code: string, asAt?: string, page?: string, limit?: number, filter?: string, sortBy?: Array<string>, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<PagedResourceListOfGeneralLedgerProfileResponse>;
    listGeneralLedgerProfiles(scope: string, code: string, asAt?: string, page?: string, limit?: number, filter?: string, sortBy?: Array<string>, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<PagedResourceListOfGeneralLedgerProfileResponse>>;
    listGeneralLedgerProfiles(scope: string, code: string, asAt?: string, page?: string, limit?: number, filter?: string, sortBy?: Array<string>, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<PagedResourceListOfGeneralLedgerProfileResponse>>;
    /**
     * [EXPERIMENTAL] ListPostingModuleRules: List Posting Module Rules
     * List the Rules in a Posting Module
     * @param scope The scope of the Chart of Accounts.
     * @param code The code of the Chart of Accounts. Together with the scope this uniquely identifies the Chart of Accounts.
     * @param postingModuleCode The code of the posting module.
     * @param asAt The asAt datetime at which to retrieve the instrument. Defaults to              returning the latest version if not specified.
     * @param page The pagination token to use to continue listing posting module rules; this              value is returned from the previous call. If a pagination token is provided, the filter              and asAt fields must not have changed since the original request.
     * @param limit When paginating, limit the results to this number. Defaults to 100 if not specified.
     * @param filter Expression to filter the results.              For example, to filter on the rule id, specify \&quot;ruleId eq \&#39;rule 1\&#39;\&quot;. For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.
     * @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.
     */
    listPostingModuleRules(scope: string, code: string, postingModuleCode: string, asAt?: string, page?: string, limit?: number, filter?: string, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<PagedResourceListOfPostingModuleRule>;
    listPostingModuleRules(scope: string, code: string, postingModuleCode: string, asAt?: string, page?: string, limit?: number, filter?: string, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<PagedResourceListOfPostingModuleRule>>;
    listPostingModuleRules(scope: string, code: string, postingModuleCode: string, asAt?: string, page?: string, limit?: number, filter?: string, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<PagedResourceListOfPostingModuleRule>>;
    /**
     * [EXPERIMENTAL] ListPostingModules: List Posting Modules
     * List all the Posting Modules matching particular criteria.
     * @param scope The scope of the Chart of Accounts.
     * @param code The code of the Chart of Accounts. Together with the scope this uniquely identifies the Chart of Accounts.
     * @param asAt The asAt datetime at which to list the Posting Module. Defaults to returning the latest version              of each Posting Module if not specified.
     * @param page The pagination token to use to continue listing Posting Modules; this              value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt              and asAt fields must not have changed since the original request.
     * @param limit When paginating, limit the results to this number. Defaults to 100 if not specified.
     * @param filter Expression to filter the results.              For example, to filter on the Posting Module status, specify \&quot;status eq \&#39;Active\&#39;\&quot;. For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.
     * @param sortBy A list of field names or properties to sort by, each suffixed by \&quot; ASC\&quot; or \&quot; DESC\&quot;.
     * @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.
     */
    listPostingModules(scope: string, code: string, asAt?: string, page?: string, limit?: number, filter?: string, sortBy?: Array<string>, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<PagedResourceListOfPostingModuleResponse>;
    listPostingModules(scope: string, code: string, asAt?: string, page?: string, limit?: number, filter?: string, sortBy?: Array<string>, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<PagedResourceListOfPostingModuleResponse>>;
    listPostingModules(scope: string, code: string, asAt?: string, page?: string, limit?: number, filter?: string, sortBy?: Array<string>, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<PagedResourceListOfPostingModuleResponse>>;
    /**
     * [EXPERIMENTAL] PatchChartOfAccounts: Patch a Chart of Accounts.
     * Update fields on a Chart of Accounts. The behaviour is defined by the JSON Patch specification.  Currently supported fields are: DisplayName, Description.
     * @param scope The scope of the Chart of Accounts.
     * @param code The code of the Chart of Accounts. Together with the scope this uniquely identifies the Chart of Accounts.
     * @param operation The json patch document. For more information see: https://datatracker.ietf.org/doc/html/rfc6902.
     * @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.
     */
    patchChartOfAccounts(scope: string, code: string, operation: Array<Operation>, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<ChartOfAccounts>;
    patchChartOfAccounts(scope: string, code: string, operation: Array<Operation>, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<ChartOfAccounts>>;
    patchChartOfAccounts(scope: string, code: string, operation: Array<Operation>, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<ChartOfAccounts>>;
    /**
     * [EXPERIMENTAL] PatchCleardownModule: Patch a Cleardown Module
     * Update fields on a Cleardown Module. The behaviour is defined by the JSON Patch specification.                Currently supported fields are: DisplayName, Description, Rules.
     * @param scope The scope of the Chart of Accounts.
     * @param code The code of the Chart of Accounts. Together with the scope this uniquely identifies the Chart of Accounts.
     * @param cleardownModuleCode The code of the Cleardown Module to be updated.
     * @param operation The json patch document. For more information see: https://datatracker.ietf.org/doc/html/rfc6902.
     * @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.
     */
    patchCleardownModule(scope: string, code: string, cleardownModuleCode: string, operation: Array<Operation>, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<CleardownModuleResponse>;
    patchCleardownModule(scope: string, code: string, cleardownModuleCode: string, operation: Array<Operation>, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<CleardownModuleResponse>>;
    patchCleardownModule(scope: string, code: string, cleardownModuleCode: string, operation: Array<Operation>, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<CleardownModuleResponse>>;
    /**
     * [EXPERIMENTAL] PatchPostingModule: Patch a Posting Module
     * Update fields on a Posting Module. The behaviour is defined by the JSON Patch specification.                Currently supported fields are: DisplayName, Description, Rules.
     * @param scope The scope of the Chart of Accounts.
     * @param code The code of the Chart of Accounts. Together with the scope this uniquely identifies the Chart of Accounts.
     * @param postingModuleCode The code of the Posting Module to be updated.
     * @param operation The json patch document. For more information see: https://datatracker.ietf.org/doc/html/rfc6902.
     * @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.
     */
    patchPostingModule(scope: string, code: string, postingModuleCode: string, operation: Array<Operation>, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<PostingModuleResponse>;
    patchPostingModule(scope: string, code: string, postingModuleCode: string, operation: Array<Operation>, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<PostingModuleResponse>>;
    patchPostingModule(scope: string, code: string, postingModuleCode: string, operation: Array<Operation>, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<PostingModuleResponse>>;
    /**
     * [EXPERIMENTAL] SetCleardownModuleDetails: Set the details of a Cleardown Module
     * Update the given Cleardown Module details.
     * @param scope The scope of the Chart of Accounts.
     * @param code The code of the Chart of Accounts. Together with the scope this uniquely identifies the Chart of Accounts.
     * @param cleardownModuleCode The code of the Cleardown Module to be updated.
     * @param cleardownModuleDetails The new details for the Cleardown Module.
     * @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.
     */
    setCleardownModuleDetails(scope: string, code: string, cleardownModuleCode: string, cleardownModuleDetails: CleardownModuleDetails, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<CleardownModuleResponse>;
    setCleardownModuleDetails(scope: string, code: string, cleardownModuleCode: string, cleardownModuleDetails: CleardownModuleDetails, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<CleardownModuleResponse>>;
    setCleardownModuleDetails(scope: string, code: string, cleardownModuleCode: string, cleardownModuleDetails: CleardownModuleDetails, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<CleardownModuleResponse>>;
    /**
     * [EXPERIMENTAL] SetCleardownModuleRules: Set the rules of a Cleardown Module
     * Set the given Cleardown Modules rules, this will replace the existing set of rules for the cleardown module.
     * @param scope The scope of the Chart of Accounts.
     * @param code The code of the Chart of Accounts. Together with the scope this uniquely identifies the Chart of Accounts.
     * @param cleardownModuleCode The code of the Cleardown Module to be updated.
     * @param cleardownModuleRule The new rule set for the Cleardown Module.
     * @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.
     */
    setCleardownModuleRules(scope: string, code: string, cleardownModuleCode: string, cleardownModuleRule: Array<CleardownModuleRule>, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<CleardownModuleRulesUpdatedResponse>;
    setCleardownModuleRules(scope: string, code: string, cleardownModuleCode: string, cleardownModuleRule: Array<CleardownModuleRule>, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<CleardownModuleRulesUpdatedResponse>>;
    setCleardownModuleRules(scope: string, code: string, cleardownModuleCode: string, cleardownModuleRule: Array<CleardownModuleRule>, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<CleardownModuleRulesUpdatedResponse>>;
    /**
     * [EXPERIMENTAL] SetGeneralLedgerProfileMappings: Sets the General Ledger Profile Mappings.
     * Update the given General Ledger profile Mappings.
     * @param scope The scope of the Chart of Accounts.
     * @param code The code of the Chart of Accounts.
     * @param generalLedgerProfileCode The code of the General Ledger Profile
     * @param generalLedgerProfileMapping The updated General Ledger Profile Mappings, the previous mappings will be wholly replaced with this data. Mappings will be evaluated in the order they are provided.
     * @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.
     */
    setGeneralLedgerProfileMappings(scope: string, code: string, generalLedgerProfileCode: string, generalLedgerProfileMapping: Array<GeneralLedgerProfileMapping>, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<GeneralLedgerProfileResponse>;
    setGeneralLedgerProfileMappings(scope: string, code: string, generalLedgerProfileCode: string, generalLedgerProfileMapping: Array<GeneralLedgerProfileMapping>, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<GeneralLedgerProfileResponse>>;
    setGeneralLedgerProfileMappings(scope: string, code: string, generalLedgerProfileCode: string, generalLedgerProfileMapping: Array<GeneralLedgerProfileMapping>, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<GeneralLedgerProfileResponse>>;
    /**
     * [EXPERIMENTAL] SetPostingModuleDetails: Set the details of a Posting Module
     * Update the given Posting Module details.
     * @param scope The scope of the Chart of Accounts.
     * @param code The code of the Chart of Accounts. Together with the scope this uniquely identifies the Chart of Accounts.
     * @param postingModuleCode The code of the Posting Module to be updated.
     * @param postingModuleDetails The new details for the Posting Module.
     * @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.
     */
    setPostingModuleDetails(scope: string, code: string, postingModuleCode: string, postingModuleDetails: PostingModuleDetails, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<PostingModuleResponse>;
    setPostingModuleDetails(scope: string, code: string, postingModuleCode: string, postingModuleDetails: PostingModuleDetails, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<PostingModuleResponse>>;
    setPostingModuleDetails(scope: string, code: string, postingModuleCode: string, postingModuleDetails: PostingModuleDetails, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<PostingModuleResponse>>;
    /**
     * [EXPERIMENTAL] SetPostingModuleRules: Set the rules of a Posting Module
     * Set the given Posting Modules rules, this will replace the existing set of rules for the posting module.
     * @param scope The scope of the Chart of Accounts.
     * @param code The code of the Chart of Accounts. Together with the scope this uniquely identifies the Chart of Accounts.
     * @param postingModuleCode The code of the Posting Module to be updated.
     * @param postingModuleRule The new rule set for the Posting Module.
     * @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.
     */
    setPostingModuleRules(scope: string, code: string, postingModuleCode: string, postingModuleRule: Array<PostingModuleRule>, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<PostingModuleRulesUpdatedResponse>;
    setPostingModuleRules(scope: string, code: string, postingModuleCode: string, postingModuleRule: Array<PostingModuleRule>, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<PostingModuleRulesUpdatedResponse>>;
    setPostingModuleRules(scope: string, code: string, postingModuleCode: string, postingModuleRule: Array<PostingModuleRule>, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<PostingModuleRulesUpdatedResponse>>;
    /**
     * [EXPERIMENTAL] UpsertAccountProperties: Upsert account properties
     * Update or insert one or more properties onto a single account. A property will be updated if it  already exists and inserted if it does not. All properties must be of the domain \&#39;Account\&#39;.                Upserting a property that exists for an account, with a null value, will delete the instance of the property for that group.                Properties have an &lt;i&gt;effectiveFrom&lt;/i&gt; datetime for which the property is valid, and an &lt;i&gt;effectiveUntil&lt;/i&gt;  datetime until which the property is valid. Not supplying an &lt;i&gt;effectiveUntil&lt;/i&gt; datetime results in the property being  valid indefinitely, or until the next &lt;i&gt;effectiveFrom&lt;/i&gt; datetime of the property.
     * @param scope The scope of the Chart of Accounts to update or insert the properties onto.
     * @param code The code of the Chart of Accounts to update or insert the properties onto. Together with the scope this uniquely identifies the Chart of Accounts.
     * @param accountCode The unique ID of the account to create or update properties for.
     * @param requestBody The properties to be updated or inserted onto the chart of account. Each property in               the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code} e.g. \&quot;Account/Manager/Id\&quot;.
     * @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.
     */
    upsertAccountProperties(scope: string, code: string, accountCode: string, requestBody?: {
        [key: string]: Property;
    }, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<AccountProperties>;
    upsertAccountProperties(scope: string, code: string, accountCode: string, requestBody?: {
        [key: string]: Property;
    }, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<AccountProperties>>;
    upsertAccountProperties(scope: string, code: string, accountCode: string, requestBody?: {
        [key: string]: Property;
    }, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<AccountProperties>>;
    /**
     * [EXPERIMENTAL] UpsertAccounts: Upsert Accounts
     * Create or update accounts in the Chart of Accounts. An account will be updated  if it already exists and created if it does not.  The maximum number of accounts that this method can upsert per request is 2,000.
     * @param scope The scope of the Chart of Accounts.
     * @param code The code of the Chart of Accounts. Together with the scope this uniquely identifies              the Chart of Accounts.
     * @param account A list of accounts to be created or updated.
     * @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.
     */
    upsertAccounts(scope: string, code: string, account: Array<Account>, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<AccountsUpsertResponse>;
    upsertAccounts(scope: string, code: string, account: Array<Account>, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<AccountsUpsertResponse>>;
    upsertAccounts(scope: string, code: string, account: Array<Account>, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<AccountsUpsertResponse>>;
    /**
     * [EXPERIMENTAL] UpsertChartOfAccountsProperties: Upsert Chart of Accounts properties
     * Update or insert one or more properties onto a single Chart of Accounts. A property will be updated if it  already exists and inserted if it does not. All properties must be of the domain \&#39;ChartOfAccounts\&#39;.                Upserting a property that exists for a Chart of Accounts, with a null value, will delete the instance of the property for that group.                Properties have an &lt;i&gt;effectiveFrom&lt;/i&gt; datetime for which the property is valid, and an &lt;i&gt;effectiveUntil&lt;/i&gt;  datetime until which the property is valid. Not supplying an &lt;i&gt;effectiveUntil&lt;/i&gt; datetime results in the property being  valid indefinitely, or until the next &lt;i&gt;effectiveFrom&lt;/i&gt; datetime of the property.
     * @param scope The scope of the Chart of Accounts to update or insert the properties onto.
     * @param code The code of the Chart of Accounts to update or insert the properties onto. Together with the scope this uniquely identifies the Chart of Accounts.
     * @param requestBody The properties to be updated or inserted onto the chart of account. Each property in               the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code} e.g. \&quot;ChartOfAccounts/Manager/Id\&quot;.
     * @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.
     */
    upsertChartOfAccountsProperties(scope: string, code: string, requestBody?: {
        [key: string]: Property;
    }, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<ChartOfAccountsProperties>;
    upsertChartOfAccountsProperties(scope: string, code: string, requestBody?: {
        [key: string]: Property;
    }, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpResponse<ChartOfAccountsProperties>>;
    upsertChartOfAccountsProperties(scope: string, code: string, requestBody?: {
        [key: string]: Property;
    }, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
    }): Observable<HttpEvent<ChartOfAccountsProperties>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChartOfAccountsService, [null, { optional: true; }, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ChartOfAccountsService>;
}