@finbourne/lusid-sdk-angular18 0.11.10068 → 0.11.10120

package/fesm2022/finbourne-lusid-sdk-angular18.mjs.map

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/fesm2022/finbourne-lusid-sdk-angular18.mjs.map
-size: 38201978 bytes
-sha256: 6249a70cdb67048f52d5fdbec9e8be644ed80f1342e4a6ce54a38a516a72fa4b
+size: 38707832 bytes
+sha256: 1d9419b114c4d0fce47dd13a49216f8845e8868de95ed4d197306b41f8dd8046

package/lib/.generated/api/allocationEvents.service.d.ts

@@ -0,0 +1,242 @@
+import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { AllocationEvent } from '../model/allocationEvent';
+import { AllocationEventBookRequest } from '../model/allocationEventBookRequest';
+import { AllocationEventReallocateRequest } from '../model/allocationEventReallocateRequest';
+import { AllocationEventRequest } from '../model/allocationEventRequest';
+import { DeletedEntityResponse } from '../model/deletedEntityResponse';
+import { PagedResourceListOfAllocationEvent } from '../model/pagedResourceListOfAllocationEvent';
+import { Configuration } from '../configuration';
+import * as i0 from "@angular/core";
+export interface BookAllocationEventRequestParams {
+    /** The scope of the Allocation Event. */
+    scope: string;
+    /** The code of the Allocation Event. Together with the scope this uniquely identifies the Allocation Event. */
+    code: string;
+    /** The booking reference to freeze the event under. */
+    allocationEventBookRequest: AllocationEventBookRequest;
+    /** The effective datetime or cut label from which the booking applies. Defaults to the current LUSID system datetime if not specified. */
+    effectiveAt?: string;
+}
+export interface CreateAllocationEventRequestParams {
+    /** The scope of the Allocation Event. */
+    scope: string;
+    /** The definition of the Allocation Event. */
+    allocationEventRequest: AllocationEventRequest;
+}
+export interface DeleteAllocationEventRequestParams {
+    /** The scope of the Allocation Event. */
+    scope: string;
+    /** The code of the Allocation Event. Together with the scope this uniquely identifies the Allocation Event. */
+    code: string;
+    /** The effective datetime or cut label from which to delete the Allocation Event. Defaults to the current LUSID system datetime if not specified. */
+    effectiveAt?: string;
+}
+export interface GetAllocationEventRequestParams {
+    /** The scope of the Allocation Event. */
+    scope: string;
+    /** The code of the Allocation Event. Together with the scope this uniquely identifies the Allocation Event. */
+    code: string;
+    /** The effective datetime or cut label at which to retrieve the Allocation Event. Defaults to the current LUSID system datetime if not specified. */
+    effectiveAt?: string;
+    /** The asAt datetime at which to retrieve the Allocation Event. Defaults to returning the latest version if not specified. */
+    asAt?: string;
+}
+export interface ListAllocationEventsRequestParams {
+    /** The effective datetime or cut label at which to list the Allocation Events. Defaults to the current LUSID system datetime if not specified. */
+    effectiveAt?: string;
+    /** The asAt datetime at which to list the Allocation Events. Defaults to returning the latest version of each Allocation Event if not specified. */
+    asAt?: string;
+    /** The pagination token to use to continue listing Allocation Events; 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. */
+    page?: string;
+    /** When paginating, limit the results to this number. Defaults to 100 if not specified. */
+    limit?: number;
+    /** Expression to filter the results. For example, to filter on the Allocation Event status, specify \"status eq \'Booked\'\".              For more information about filtering LUSID results, see https://support.lusid.com/knowledgebase/article/KA-01914. */
+    filter?: string;
+    /** A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\". */
+    sortBy?: Array<string>;
+}
+export interface ReallocateAllocationEventRequestParams {
+    /** The scope of the Allocation Event. */
+    scope: string;
+    /** The code of the Allocation Event. Together with the scope this uniquely identifies the Allocation Event. */
+    code: string;
+    /** The reason for the reallocation and any basis values to use. */
+    allocationEventReallocateRequest: AllocationEventReallocateRequest;
+    /** The effective datetime or cut label from which the reallocation applies. Defaults to the current LUSID system datetime if not specified. */
+    effectiveAt?: string;
+}
+export interface UpsertAllocationEventRequestParams {
+    /** The scope of the Allocation Event. */
+    scope: string;
+    /** The code of the Allocation Event. Together with the scope this uniquely identifies the Allocation Event. */
+    code: string;
+    /** The definition of the Allocation Event. */
+    allocationEventRequest: AllocationEventRequest;
+}
+export declare class AllocationEventsService {
+    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] BookAllocationEvent: Book an Allocation Event.
+     * Freeze a computed Allocation Event under a booking reference, from an effective datetime. Once booked the  event can no longer be replaced or reallocated. Booking again under the same reference returns the event  unchanged; booking under a different reference is refused.
+     * @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.
+     */
+    bookAllocationEvent(requestParameters?: BookAllocationEventRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<AllocationEvent>;
+    bookAllocationEvent(requestParameters?: BookAllocationEventRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<AllocationEvent>>;
+    bookAllocationEvent(requestParameters?: BookAllocationEventRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<AllocationEvent>>;
+    /**
+     * [EXPERIMENTAL] CreateAllocationEvent: Create an Allocation Event.
+     * Raise a new Allocation Event. The scope is provided in the route and the code in the request body. The event  names the Allocation Map it is shared by, the kind of event, the amount and the date. Its per-investor shares  are computed on creation from the map as it stood on the event date, so the response comes back Computed.
+     * @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.
+     */
+    createAllocationEvent(requestParameters?: CreateAllocationEventRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<AllocationEvent>;
+    createAllocationEvent(requestParameters?: CreateAllocationEventRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<AllocationEvent>>;
+    createAllocationEvent(requestParameters?: CreateAllocationEventRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<AllocationEvent>>;
+    /**
+     * [EXPERIMENTAL] DeleteAllocationEvent: Delete an Allocation Event.
+     * Delete an Allocation Event from an effective datetime. The Allocation Event remains retrievable at earlier  effective datetimes.
+     * @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.
+     */
+    deleteAllocationEvent(requestParameters?: DeleteAllocationEventRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<DeletedEntityResponse>;
+    deleteAllocationEvent(requestParameters?: DeleteAllocationEventRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<DeletedEntityResponse>>;
+    deleteAllocationEvent(requestParameters?: DeleteAllocationEventRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<DeletedEntityResponse>>;
+    /**
+     * [EXPERIMENTAL] GetAllocationEvent: Get an Allocation Event.
+     * Retrieve a particular Allocation Event at an effective and asAt datetime, including its computed  per-investor shares and, once booked, its booking reference.
+     * @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.
+     */
+    getAllocationEvent(requestParameters?: GetAllocationEventRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<AllocationEvent>;
+    getAllocationEvent(requestParameters?: GetAllocationEventRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<AllocationEvent>>;
+    getAllocationEvent(requestParameters?: GetAllocationEventRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<AllocationEvent>>;
+    /**
+     * [EXPERIMENTAL] ListAllocationEvents: List Allocation Events.
+     * List all the Allocation Events matching a particular criteria.
+     * @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.
+     */
+    listAllocationEvents(requestParameters?: ListAllocationEventsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<PagedResourceListOfAllocationEvent>;
+    listAllocationEvents(requestParameters?: ListAllocationEventsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<PagedResourceListOfAllocationEvent>>;
+    listAllocationEvents(requestParameters?: ListAllocationEventsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<PagedResourceListOfAllocationEvent>>;
+    /**
+     * [EXPERIMENTAL] ReallocateAllocationEvent: Reallocate an Allocation Event.
+     * Recompute the per-investor shares of an unbooked Allocation Event against its map, from an effective  datetime, recording the reason. Any basis values supplied replace those used before. A booked Allocation  Event cannot be reallocated.
+     * @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.
+     */
+    reallocateAllocationEvent(requestParameters?: ReallocateAllocationEventRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<AllocationEvent>;
+    reallocateAllocationEvent(requestParameters?: ReallocateAllocationEventRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<AllocationEvent>>;
+    reallocateAllocationEvent(requestParameters?: ReallocateAllocationEventRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<AllocationEvent>>;
+    /**
+     * [EXPERIMENTAL] UpsertAllocationEvent: Upsert an Allocation Event.
+     * Update or insert an Allocation Event. If the Allocation Event does not exist it is created, otherwise it is  replaced and its shares recomputed. The code in the request body must match the code in the route. A booked  Allocation Event is frozen and cannot be replaced.
+     * @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.
+     */
+    upsertAllocationEvent(requestParameters?: UpsertAllocationEventRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<AllocationEvent>;
+    upsertAllocationEvent(requestParameters?: UpsertAllocationEventRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<AllocationEvent>>;
+    upsertAllocationEvent(requestParameters?: UpsertAllocationEventRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<AllocationEvent>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AllocationEventsService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AllocationEventsService>;
+}

package/lib/.generated/api/allocationMaps.service.d.ts

@@ -0,0 +1,277 @@
+import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { AllocationMap } from '../model/allocationMap';
+import { AllocationMapException } from '../model/allocationMapException';
+import { AllocationMapRequest } from '../model/allocationMapRequest';
+import { AllocationMapResolution } from '../model/allocationMapResolution';
+import { AllocationMapResolveRequest } from '../model/allocationMapResolveRequest';
+import { DeletedEntityResponse } from '../model/deletedEntityResponse';
+import { PagedResourceListOfAllocationMap } from '../model/pagedResourceListOfAllocationMap';
+import { Configuration } from '../configuration';
+import * as i0 from "@angular/core";
+export interface AddAllocationMapExceptionRequestParams {
+    /** The scope of the Allocation Map. */
+    scope: string;
+    /** The code of the Allocation Map. Together with the scope this uniquely identifies the Allocation Map. */
+    code: string;
+    /** The exception to add. */
+    allocationMapException: AllocationMapException;
+    /** The effective datetime or cut label from which the exception applies. Defaults to the current LUSID system datetime if not specified. */
+    effectiveAt?: string;
+}
+export interface CreateAllocationMapRequestParams {
+    /** The scope of the Allocation Map. */
+    scope: string;
+    /** The definition of the Allocation Map. */
+    allocationMapRequest: AllocationMapRequest;
+}
+export interface DeleteAllocationMapRequestParams {
+    /** The scope of the Allocation Map. */
+    scope: string;
+    /** The code of the Allocation Map. Together with the scope this uniquely identifies the Allocation Map. */
+    code: string;
+    /** The effective datetime or cut label from which the Allocation Map is deleted. Defaults to the current LUSID system datetime if not specified. */
+    effectiveAt?: string;
+}
+export interface GetAllocationMapRequestParams {
+    /** The scope of the Allocation Map. */
+    scope: string;
+    /** The code of the Allocation Map. Together with the scope this uniquely identifies the Allocation Map. */
+    code: string;
+    /** The effective datetime or cut label at which to retrieve the Allocation Map. Defaults to the current LUSID system datetime if not specified. */
+    effectiveAt?: string;
+    /** The asAt datetime at which to retrieve the Allocation Map. Defaults to returning the latest version if not specified. */
+    asAt?: string;
+}
+export interface ListAllocationMapsRequestParams {
+    /** The effective datetime or cut label at which to list the Allocation Maps. Defaults to the current LUSID system datetime if not specified. */
+    effectiveAt?: string;
+    /** The asAt datetime at which to list the Allocation Maps. Defaults to returning the latest version of each Allocation Map if not specified. */
+    asAt?: string;
+    /** The pagination token to use to continue listing Allocation Maps; 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. */
+    page?: string;
+    /** When paginating, limit the results to this number. Defaults to 100 if not specified. */
+    limit?: number;
+    /** Expression to filter the results. For example, to filter on the Allocation Map code, specify \"id.Code eq \'AllocationMap1\'\".              For more information about filtering LUSID results, see https://support.lusid.com/knowledgebase/article/KA-01914. */
+    filter?: string;
+    /** A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\". */
+    sortBy?: Array<string>;
+}
+export interface RemoveAllocationMapExceptionRequestParams {
+    /** The scope of the Allocation Map. */
+    scope: string;
+    /** The code of the Allocation Map. Together with the scope this uniquely identifies the Allocation Map. */
+    code: string;
+    /** The investor record whose exception is removed. */
+    investorRecordId: string;
+    /** The effective datetime or cut label from which the exception no longer applies. Defaults to the current LUSID system datetime if not specified. */
+    effectiveAt?: string;
+}
+export interface ResolveAllocationMapRequestParams {
+    /** The scope of the Allocation Map. */
+    scope: string;
+    /** The code of the Allocation Map. Together with the scope this uniquely identifies the Allocation Map. */
+    code: string;
+    /** The event to resolve and the basis values to use. */
+    allocationMapResolveRequest: AllocationMapResolveRequest;
+    /** The effective datetime or cut label at which to resolve the map. Defaults to the current LUSID system datetime if not specified. */
+    effectiveAt?: string;
+    /** The asAt datetime at which to read the map. Defaults to the latest version if not specified. */
+    asAt?: string;
+}
+export interface UpsertAllocationMapRequestParams {
+    /** The scope of the Allocation Map. */
+    scope: string;
+    /** The code of the Allocation Map. Together with the scope this uniquely identifies the Allocation Map. */
+    code: string;
+    /** The definition of the Allocation Map. */
+    allocationMapRequest: AllocationMapRequest;
+}
+export declare class AllocationMapsService {
+    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] AddAllocationMapException: Add an exception to an Allocation Map.
+     * Add a per-investor exception (an exclusion or a fixed percentage) to the map\&#39;s participants, from an  effective datetime. The result is a new bitemporal version of the map. An investor record may carry at most  one exception; to change it, remove the existing one first or upsert the whole map.
+     * @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.
+     */
+    addAllocationMapException(requestParameters?: AddAllocationMapExceptionRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<AllocationMap>;
+    addAllocationMapException(requestParameters?: AddAllocationMapExceptionRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<AllocationMap>>;
+    addAllocationMapException(requestParameters?: AddAllocationMapExceptionRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<AllocationMap>>;
+    /**
+     * [EXPERIMENTAL] CreateAllocationMap: Create an Allocation Map.
+     * Create a new Allocation Map. The scope is provided in the route and the code in the request body. The map  names the structure member it hangs off, who participates, and the basis used to share each kind of event.
+     * @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.
+     */
+    createAllocationMap(requestParameters?: CreateAllocationMapRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<AllocationMap>;
+    createAllocationMap(requestParameters?: CreateAllocationMapRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<AllocationMap>>;
+    createAllocationMap(requestParameters?: CreateAllocationMapRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<AllocationMap>>;
+    /**
+     * [EXPERIMENTAL] DeleteAllocationMap: Delete an Allocation Map.
+     * Delete an Allocation Map from an effective datetime. The Allocation Map is no longer readable from that  effective datetime onwards.
+     * @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.
+     */
+    deleteAllocationMap(requestParameters?: DeleteAllocationMapRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<DeletedEntityResponse>;
+    deleteAllocationMap(requestParameters?: DeleteAllocationMapRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<DeletedEntityResponse>>;
+    deleteAllocationMap(requestParameters?: DeleteAllocationMapRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<DeletedEntityResponse>>;
+    /**
+     * [EXPERIMENTAL] GetAllocationMap: Get an Allocation Map.
+     * Retrieve the definition of a particular Allocation Map at an effective and asAt datetime, including its  participants, exceptions and the basis declared for each event type.
+     * @param requestParameters
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    getAllocationMap(requestParameters?: GetAllocationMapRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<AllocationMap>;
+    getAllocationMap(requestParameters?: GetAllocationMapRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<AllocationMap>>;
+    getAllocationMap(requestParameters?: GetAllocationMapRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<AllocationMap>>;
+    /**
+     * [EXPERIMENTAL] ListAllocationMaps: List Allocation Maps.
+     * List all the Allocation Maps matching a particular criteria.
+     * @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.
+     */
+    listAllocationMaps(requestParameters?: ListAllocationMapsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<PagedResourceListOfAllocationMap>;
+    listAllocationMaps(requestParameters?: ListAllocationMapsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<PagedResourceListOfAllocationMap>>;
+    listAllocationMaps(requestParameters?: ListAllocationMapsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<PagedResourceListOfAllocationMap>>;
+    /**
+     * [EXPERIMENTAL] RemoveAllocationMapException: Remove an exception from an Allocation Map.
+     * Remove the exception held against an investor record, from an effective datetime. The result is a new  bitemporal version of the map in which that investor is treated like every other participant.
+     * @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.
+     */
+    removeAllocationMapException(requestParameters?: RemoveAllocationMapExceptionRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<AllocationMap>;
+    removeAllocationMapException(requestParameters?: RemoveAllocationMapExceptionRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<AllocationMap>>;
+    removeAllocationMapException(requestParameters?: RemoveAllocationMapExceptionRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<AllocationMap>>;
+    /**
+     * [EXPERIMENTAL] ResolveAllocationMap: Resolve an Allocation Map.
+     * Dry-run the map against an event: share the supplied amount across the participants in force at the  effective datetime, applying fixed-percentage exceptions off the top and the declared basis to the remainder.  Nothing is booked. Basis values (for example committed capital per investor) are supplied in the request  until the investor register can provide them.
+     * @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.
+     */
+    resolveAllocationMap(requestParameters?: ResolveAllocationMapRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<AllocationMapResolution>;
+    resolveAllocationMap(requestParameters?: ResolveAllocationMapRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<AllocationMapResolution>>;
+    resolveAllocationMap(requestParameters?: ResolveAllocationMapRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<AllocationMapResolution>>;
+    /**
+     * [EXPERIMENTAL] UpsertAllocationMap: Upsert an Allocation Map.
+     * Update or insert an Allocation Map. If the Allocation Map does not exist it is created, otherwise it is  updated. The code in the request body must match the code in the route.
+     * @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.
+     */
+    upsertAllocationMap(requestParameters?: UpsertAllocationMapRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<AllocationMap>;
+    upsertAllocationMap(requestParameters?: UpsertAllocationMapRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<AllocationMap>>;
+    upsertAllocationMap(requestParameters?: UpsertAllocationMapRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<AllocationMap>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AllocationMapsService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AllocationMapsService>;
+}

package/lib/.generated/api/api.d.ts

@@ -10,6 +10,10 @@ export * from './aggregatedReturns.service';
 import { AggregatedReturnsService } from './aggregatedReturns.service';
 export * from './aggregation.service';
 import { AggregationService } from './aggregation.service';
+export * from './allocationEvents.service';
+import { AllocationEventsService } from './allocationEvents.service';
+export * from './allocationMaps.service';
+import { AllocationMapsService } from './allocationMaps.service';
 export * from './allocations.service';
 import { AllocationsService } from './allocations.service';
 export * from './amortisationRuleSets.service';
@@ -184,4 +188,4 @@ export * from './withholdingTax.service';
 import { WithholdingTaxService } from './withholdingTax.service';
 export * from './workspace.service';
 import { WorkspaceService } from './workspace.service';
-export declare const APIS: (typeof AborService | typeof AborConfigurationService | typeof AddressKeyAliasService | typeof AddressKeyDefinitionService | typeof AggregatedReturnsService | typeof AggregationService | typeof AllocationsService | typeof AmortisationRuleSetsService | typeof ApplicationMetadataService | typeof BlocksService | typeof CalendarsService | typeof ChartOfAccountsService | typeof CheckDefinitionsService | typeof ComplexMarketDataService | typeof ComplianceService | typeof ConfigurationRecipeService | typeof ConventionsService | typeof CorporateActionSourcesService | typeof CounterpartiesService | typeof CurrencyGroupsService | typeof CustomDataModelsService | typeof CustomEntitiesService | typeof CustomEntityDefinitionsService | typeof CustomEntityTypesService | typeof CutLabelDefinitionsService | typeof DataTypesService | typeof DerivedTransactionPortfoliosService | typeof EntitiesService | typeof EntityResolversService | typeof ExecutionsService | typeof FeeTypesService | typeof FundConfigurationService | typeof FundStructuresService | typeof FundsService | typeof GroupReconciliationsService | typeof IdentifierDefinitionsService | typeof InstrumentEventTypesService | typeof InstrumentEventsService | typeof InstrumentsService | typeof InvestmentAccountsService | typeof InvestorRecordsService | typeof LegacyComplianceService | typeof LegalEntitiesService | typeof MarketDataFieldConfigurationService | typeof OrderGraphService | typeof OrderInstructionsService | typeof OrderManagementService | typeof OrdersService | typeof PackagesService | typeof ParticipationsService | typeof PaymentInstructionsService | typeof PersonsService | typeof PlacementsService | typeof PortfolioGroupsService | typeof PortfoliosService | typeof PropertyDefinitionsService | typeof QueryableKeysService | typeof QuotesService | typeof ReconciliationsService | typeof RecsService | typeof ReferenceListsService | typeof ReferencePortfolioService | typeof RelationDefinitionsService | typeof RelationalDatasetDefinitionService | typeof RelationalDatasetsService | typeof RelationsService | typeof RelationshipDefinitionsService | typeof RelationshipsService | typeof ResourceRecordService | typeof ScenariosService | typeof SchemasService | typeof ScopesService | typeof ScriptedTranslationService | typeof SearchService | typeof SequencesService | typeof SettlementActivityService | typeof SimplePositionPortfoliosService | typeof StagedModificationsService | typeof StagingRuleSetService | typeof StructuredResultDataService | typeof SubscriptionsService | typeof SystemConfigurationService | typeof TaxRuleSetsService | typeof TimelinesService | typeof TransactionConfigurationService | typeof TransactionFeeTypesService | typeof TransactionFeesService | typeof TransactionPortfoliosService | typeof TransferAgencyService | typeof TransfersService | typeof TranslationService | typeof WithholdingTaxService | typeof WorkspaceService)[];
+export declare const APIS: (typeof AborService | typeof AborConfigurationService | typeof AddressKeyAliasService | typeof AddressKeyDefinitionService | typeof AggregatedReturnsService | typeof AggregationService | typeof AllocationEventsService | typeof AllocationMapsService | typeof AllocationsService | typeof AmortisationRuleSetsService | typeof ApplicationMetadataService | typeof BlocksService | typeof CalendarsService | typeof ChartOfAccountsService | typeof CheckDefinitionsService | typeof ComplexMarketDataService | typeof ComplianceService | typeof ConfigurationRecipeService | typeof ConventionsService | typeof CorporateActionSourcesService | typeof CounterpartiesService | typeof CurrencyGroupsService | typeof CustomDataModelsService | typeof CustomEntitiesService | typeof CustomEntityDefinitionsService | typeof CustomEntityTypesService | typeof CutLabelDefinitionsService | typeof DataTypesService | typeof DerivedTransactionPortfoliosService | typeof EntitiesService | typeof EntityResolversService | typeof ExecutionsService | typeof FeeTypesService | typeof FundConfigurationService | typeof FundStructuresService | typeof FundsService | typeof GroupReconciliationsService | typeof IdentifierDefinitionsService | typeof InstrumentEventTypesService | typeof InstrumentEventsService | typeof InstrumentsService | typeof InvestmentAccountsService | typeof InvestorRecordsService | typeof LegacyComplianceService | typeof LegalEntitiesService | typeof MarketDataFieldConfigurationService | typeof OrderGraphService | typeof OrderInstructionsService | typeof OrderManagementService | typeof OrdersService | typeof PackagesService | typeof ParticipationsService | typeof PaymentInstructionsService | typeof PersonsService | typeof PlacementsService | typeof PortfolioGroupsService | typeof PortfoliosService | typeof PropertyDefinitionsService | typeof QueryableKeysService | typeof QuotesService | typeof ReconciliationsService | typeof RecsService | typeof ReferenceListsService | typeof ReferencePortfolioService | typeof RelationDefinitionsService | typeof RelationalDatasetDefinitionService | typeof RelationalDatasetsService | typeof RelationsService | typeof RelationshipDefinitionsService | typeof RelationshipsService | typeof ResourceRecordService | typeof ScenariosService | typeof SchemasService | typeof ScopesService | typeof ScriptedTranslationService | typeof SearchService | typeof SequencesService | typeof SettlementActivityService | typeof SimplePositionPortfoliosService | typeof StagedModificationsService | typeof StagingRuleSetService | typeof StructuredResultDataService | typeof SubscriptionsService | typeof SystemConfigurationService | typeof TaxRuleSetsService | typeof TimelinesService | typeof TransactionConfigurationService | typeof TransactionFeeTypesService | typeof TransactionFeesService | typeof TransactionPortfoliosService | typeof TransferAgencyService | typeof TransfersService | typeof TranslationService | typeof WithholdingTaxService | typeof WorkspaceService)[];

package/lib/.generated/api/compliance.service.d.ts

@@ -9,6 +9,7 @@ import { ComplianceRunInfoV2 } from '../model/complianceRunInfoV2';
 import { ComplianceTemplate } from '../model/complianceTemplate';
 import { CreateComplianceTemplateRequest } from '../model/createComplianceTemplateRequest';
 import { DecoratedComplianceRunSummary } from '../model/decoratedComplianceRunSummary';
+import { DecoratedComplianceRunSummaryRequest } from '../model/decoratedComplianceRunSummaryRequest';
 import { DeletedEntityResponse } from '../model/deletedEntityResponse';
 import { PagedResourceListOfComplianceRuleResponse } from '../model/pagedResourceListOfComplianceRuleResponse';
 import { PagedResourceListOfComplianceRunInfoV2 } from '../model/pagedResourceListOfComplianceRunInfoV2';
@@ -84,6 +85,10 @@ export interface GetDecoratedComplianceRunSummaryRequestParams {
     /** A list of property keys from the \'Compliance\' domain to decorate onto each rule result.              These must take the format {domain}/{scope}/{code}, for example \'Compliance/live/UCITS\'. */
     propertyKeys?: Array<string>;
 }
+export interface GetFilteredDecoratedComplianceRunSummaryRequestParams {
+    /** The run to summarise, the optional portfolio/portfolio-group filter, and the property keys to decorate. */
+    decoratedComplianceRunSummaryRequest?: DecoratedComplianceRunSummaryRequest;
+}
 export interface ListComplianceRulesRequestParams {
     /** Optional. Asat time. */
     asAt?: string;
@@ -353,6 +358,28 @@ export declare class ComplianceService {
         context?: HttpContext;
         transferCache?: boolean;
     }): Observable<HttpEvent<DecoratedComplianceRunSummary>>;
+    /**
+     * [EARLY ACCESS] GetFilteredDecoratedComplianceRunSummary: Get decorated summary results for a specific compliance run, optionally restricted to a set of portfolios or portfolio groups.
+     * Specify a run scope and code from a previously run compliance check to get an overview of result details.  Supply an optional list of portfolios and/or portfolio groups to return only the rule results affecting them;  portfolio groups are expanded to their member portfolios (including nested groups). An empty or omitted list  returns the full, unfiltered summary.
+     * @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.
+     */
+    getFilteredDecoratedComplianceRunSummary(requestParameters?: GetFilteredDecoratedComplianceRunSummaryRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<DecoratedComplianceRunSummary>;
+    getFilteredDecoratedComplianceRunSummary(requestParameters?: GetFilteredDecoratedComplianceRunSummaryRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<DecoratedComplianceRunSummary>>;
+    getFilteredDecoratedComplianceRunSummary(requestParameters?: GetFilteredDecoratedComplianceRunSummaryRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<DecoratedComplianceRunSummary>>;
     /**
      * [EARLY ACCESS] ListComplianceRules: List compliance rules.
      * Use this endpoint to retrieve all compliance rules, or a subset defined by an optional filter.