import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from '@angular/common/http';
import { Observable } from 'rxjs';
import { AddBusinessDaysToDateRequest } from '../model/addBusinessDaysToDateRequest';
import { AddBusinessDaysToDateResponse } from '../model/addBusinessDaysToDateResponse';
import { BatchUpsertDatesForCalendarResponse } from '../model/batchUpsertDatesForCalendarResponse';
import { Calendar } from '../model/calendar';
import { CalendarDate } from '../model/calendarDate';
import { CreateCalendarRequest } from '../model/createCalendarRequest';
import { CreateDateRequest } from '../model/createDateRequest';
import { IsBusinessDayResponse } from '../model/isBusinessDayResponse';
import { PagedResourceListOfCalendar } from '../model/pagedResourceListOfCalendar';
import { ResourceListOfCalendarDate } from '../model/resourceListOfCalendarDate';
import { UpdateCalendarRequest } from '../model/updateCalendarRequest';
import { ValuationSchedule } from '../model/valuationSchedule';
import { Configuration } from '../configuration';
import * as i0 from "@angular/core";
export interface AddBusinessDaysToDateRequestParams {
    /** Scope within which to search for the calendars */
    scope: string;
    /** Request Details: start date, number of days to add (which can be negative, but not zero), calendar codes and optionally an AsAt date for searching the calendar store */
    addBusinessDaysToDateRequest: AddBusinessDaysToDateRequest;
}
export interface AddDateToCalendarRequestParams {
    /** Scope of the calendar */
    scope: string;
    /** Code of the calendar */
    code: string;
    /** Add date to calendar request */
    createDateRequest: CreateDateRequest;
}
export interface BatchUpsertDatesForCalendarRequestParams {
    /** Scope of the calendar */
    scope: string;
    /** Code of the calendar */
    code: string;
    /** Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial. */
    successMode: string;
    /** Create Date Requests of dates to upsert */
    requestBody: {
        [key: string]: CreateDateRequest;
    };
}
export interface CreateCalendarRequestParams {
    /** A request to create the calendar */
    createCalendarRequest: CreateCalendarRequest;
}
export interface DeleteCalendarRequestParams {
    /** Scope of the calendar */
    scope: string;
    /** Code of the calendar */
    code: string;
}
export interface DeleteDateFromCalendarRequestParams {
    /** Scope of the calendar */
    scope: string;
    /** Code of the calendar */
    code: string;
    /** Identifier of the date to be removed */
    dateId: string;
}
export interface DeleteDatesFromCalendarRequestParams {
    /** Scope of the calendar */
    scope: string;
    /** Code of the calendar */
    code: string;
    /** Identifiers of the dates to be removed */
    requestBody: Array<string>;
}
export interface GenerateScheduleRequestParams {
    /** Scope of the calendars to use */
    scope: string;
    /** The ValuationSchedule to generate schedule dates from */
    valuationSchedule: ValuationSchedule;
    /** Optional AsAt for searching the calendar store. Defaults to Latest. */
    asAt?: string;
}
export interface GetCalendarRequestParams {
    /** Scope of the calendar identifier */
    scope: string;
    /** Code of the calendar identifier */
    code: string;
    /** A list of property keys from the \&quot;Calendar\&quot; domain to decorate onto the calendar,               These take the format {domain}/{scope}/{code} e.g. \&quot;Calendar/System/Name\&quot;. */
    propertyKeys?: Array<string>;
    /** The AsAt datetime at which to retrieve the calendar */
    asAt?: string;
}
export interface GetDatesRequestParams {
    /** Scope of the calendar */
    scope: string;
    /** Code of the calendar */
    code: string;
    /** Where the effective window of dates should begin from */
    fromEffectiveAt?: string;
    /** Where the effective window of dates should end */
    toEffectiveAt?: string;
    /** AsAt the dates should be retrieved at */
    asAt?: string;
    /** An additional filter that will filter dates based on their identifer */
    idFilter?: Array<string>;
}
export interface IsBusinessDateTimeRequestParams {
    /** DateTime to check - This DateTime must be UTC */
    dateTime: string;
    /** Scope of the calendar */
    scope: string;
    /** Code of the calendar */
    code: string;
    /** AsAt for the request */
    asAt?: string;
}
export interface ListCalendarsRequestParams {
    /** The AsAt datetime at which to retrieve the calendars */
    asAt?: string;
    /** The pagination token to use to continue listing calendars from a previous call to list calendars.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, and asAt fields              must not have changed since the original request. */
    page?: string;
    /** When paginating, limit the number of returned results to this many. */
    limit?: number;
    /** A list of property keys from the \&quot;Calendar\&quot; domain to decorate onto the calendar,               These take the format {domain}/{scope}/{code} e.g. \&quot;Calendar/System/Name\&quot;. */
    propertyKeys?: Array<string>;
    /** Expression to filter the result set. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid. */
    filter?: string;
}
export interface ListCalendarsInScopeRequestParams {
    /** Scope of the calendars */
    scope: string;
    /** The AsAt datetime at which to retrieve the calendars */
    asAt?: string;
    /** The pagination token to use to continue listing calendars from a previous call to list calendars.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, and asAt fields              must not have changed since the original request. */
    page?: string;
    /** When paginating, limit the number of returned results to this many. */
    limit?: number;
    /** A list of property keys from the \&quot;Calendar\&quot; domain to decorate onto the calendar,               These take the format {domain}/{scope}/{code} e.g. \&quot;Calendar/System/Name\&quot;. */
    propertyKeys?: Array<string>;
    /** Expression to filter the result set. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid. */
    filter?: string;
}
export interface UpdateCalendarRequestParams {
    /** Scope of the request */
    scope: string;
    /** Code of the request */
    code: string;
    /** The new state of the calendar */
    updateCalendarRequest: UpdateCalendarRequest;
}
export declare class CalendarsService {
    protected httpClient: HttpClient;
    protected basePath: string;
    defaultHeaders: HttpHeaders;
    configuration: Configuration;
    encoder: HttpParameterCodec;
    constructor(httpClient: HttpClient, basePath: string | string[], configuration: Configuration);
    private addToHttpParams;
    private addToHttpParamsRecursive;
    /**
     * [EARLY ACCESS] AddBusinessDaysToDate: Adds the requested number of Business Days to the provided date.
     * A Business day is defined as a point in time that:      * Does not represent a day in the calendar\&#39;s weekend      * Does not represent a day in the calendar\&#39;s list of holidays (e.g. Christmas Day in the UK)                 All dates specified must be UTC and the upper bound of a calendar is not inclusive                 e.g. From: 2020-12-24-00-00-00:       Adding 3 business days returns 2020-12-30, assuming Saturday and Sunday are weekends, and the 25th and 28th are holidays.       Adding -2 business days returns 2020-12-22 under the same assumptions.                If the provided number of days to add is zero, returns a failure.
     * @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.
     */
    addBusinessDaysToDate(requestParameters?: AddBusinessDaysToDateRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<AddBusinessDaysToDateResponse>;
    addBusinessDaysToDate(requestParameters?: AddBusinessDaysToDateRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<AddBusinessDaysToDateResponse>>;
    addBusinessDaysToDate(requestParameters?: AddBusinessDaysToDateRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<AddBusinessDaysToDateResponse>>;
    /**
     * AddDateToCalendar: Add a date to a calendar
     * Add an event to the calendar. These Events can be a maximum of 24 hours and must be specified in UTC.  A local date will be calculated by the system and applied to the calendar before processing.
     * @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.
     */
    addDateToCalendar(requestParameters?: AddDateToCalendarRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<CalendarDate>;
    addDateToCalendar(requestParameters?: AddDateToCalendarRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<CalendarDate>>;
    addDateToCalendar(requestParameters?: AddDateToCalendarRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<CalendarDate>>;
    /**
     * BatchUpsertDatesForCalendar: Batch upsert dates to a calendar
     * Create or update events in the calendar. These Events can be a maximum of 24 hours and must be specified in UTC.  A local date will be calculated by the system and applied to the calendar before processing.
     * @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.
     */
    batchUpsertDatesForCalendar(requestParameters?: BatchUpsertDatesForCalendarRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<BatchUpsertDatesForCalendarResponse>;
    batchUpsertDatesForCalendar(requestParameters?: BatchUpsertDatesForCalendarRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<BatchUpsertDatesForCalendarResponse>>;
    batchUpsertDatesForCalendar(requestParameters?: BatchUpsertDatesForCalendarRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<BatchUpsertDatesForCalendarResponse>>;
    /**
     * [EARLY ACCESS] CreateCalendar: Create a calendar in its generic form
     * Create a calendar in a generic form which can be used to store date events.
     * @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.
     */
    createCalendar(requestParameters?: CreateCalendarRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<Calendar>;
    createCalendar(requestParameters?: CreateCalendarRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<Calendar>>;
    createCalendar(requestParameters?: CreateCalendarRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<Calendar>>;
    /**
     * [EARLY ACCESS] DeleteCalendar: Delete a calendar
     * Delete a calendar and all of its respective dates
     * @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.
     */
    deleteCalendar(requestParameters?: DeleteCalendarRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<Calendar>;
    deleteCalendar(requestParameters?: DeleteCalendarRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<Calendar>>;
    deleteCalendar(requestParameters?: DeleteCalendarRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<Calendar>>;
    /**
     * DeleteDateFromCalendar: Remove a date from a calendar
     * Remove a date from a calendar.
     * @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.
     */
    deleteDateFromCalendar(requestParameters?: DeleteDateFromCalendarRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<CalendarDate>;
    deleteDateFromCalendar(requestParameters?: DeleteDateFromCalendarRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<CalendarDate>>;
    deleteDateFromCalendar(requestParameters?: DeleteDateFromCalendarRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<CalendarDate>>;
    /**
     * DeleteDatesFromCalendar: Delete dates from a calendar
     * Delete dates from a calendar.
     * @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.
     */
    deleteDatesFromCalendar(requestParameters?: DeleteDatesFromCalendarRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<{
        [key: string]: CalendarDate;
    }>;
    deleteDatesFromCalendar(requestParameters?: DeleteDatesFromCalendarRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<{
        [key: string]: CalendarDate;
    }>>;
    deleteDatesFromCalendar(requestParameters?: DeleteDatesFromCalendarRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<{
        [key: string]: CalendarDate;
    }>>;
    /**
     * [EARLY ACCESS] GenerateSchedule: Generate an ordered schedule of dates.
     * Returns an ordered array of dates. The dates will only fall on business  days as defined by the scope and calendar codes in the valuation schedule.                Valuations are made at a frequency defined by the valuation schedule\&#39;s tenor, e.g. every day (\&quot;1D\&quot;),  every other week (\&quot;2W\&quot;) etc. These dates will be adjusted onto business days as defined by the schedule\&#39;s  rollConvention.
     * @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.
     */
    generateSchedule(requestParameters?: GenerateScheduleRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<Array<string>>;
    generateSchedule(requestParameters?: GenerateScheduleRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<Array<string>>>;
    generateSchedule(requestParameters?: GenerateScheduleRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<Array<string>>>;
    /**
     * GetCalendar: Get a calendar in its generic form
     * Retrieve a generic calendar by a specific ID at a point in AsAt time
     * @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.
     */
    getCalendar(requestParameters?: GetCalendarRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<Calendar>;
    getCalendar(requestParameters?: GetCalendarRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<Calendar>>;
    getCalendar(requestParameters?: GetCalendarRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<Calendar>>;
    /**
     * [EARLY ACCESS] GetDates: Get dates for a specific calendar
     * Get dates from a specific calendar within a specific window of effective time, at a point in AsAt time.  Providing an id filter can further refine the results.
     * @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.
     */
    getDates(requestParameters?: GetDatesRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<ResourceListOfCalendarDate>;
    getDates(requestParameters?: GetDatesRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<ResourceListOfCalendarDate>>;
    getDates(requestParameters?: GetDatesRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<ResourceListOfCalendarDate>>;
    /**
     * [EARLY ACCESS] IsBusinessDateTime: Check whether a DateTime is a \&quot;Business DateTime\&quot;
     * A Business DateTime is defined as a point in time that:      * Does not represent a day that overlaps with the calendars WeekendMask      * If the calendar is a \&quot;Holiday Calendar\&quot; Does not overlap with any dates in the calendar      * If the calendar is a \&quot;TradingHours Calendar\&quot; Does overlap with a date in the calendar                All dates specified must be UTC and the upper bound of a calendar is not inclusive   e.g. From: 2020-12-25-00-00-00        To: 2020-12-26-00-00-00  IsBusinessDay(2020-12-26-00-00-00) &#x3D;&#x3D; false
     * @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.
     */
    isBusinessDateTime(requestParameters?: IsBusinessDateTimeRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<IsBusinessDayResponse>;
    isBusinessDateTime(requestParameters?: IsBusinessDateTimeRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<IsBusinessDayResponse>>;
    isBusinessDateTime(requestParameters?: IsBusinessDateTimeRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<IsBusinessDayResponse>>;
    /**
     * [EARLY ACCESS] ListCalendars: List Calendars
     * List calendars at a point in AsAt time.
     * @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.
     */
    listCalendars(requestParameters?: ListCalendarsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<PagedResourceListOfCalendar>;
    listCalendars(requestParameters?: ListCalendarsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<PagedResourceListOfCalendar>>;
    listCalendars(requestParameters?: ListCalendarsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<PagedResourceListOfCalendar>>;
    /**
     * ListCalendarsInScope: List all calenders in a specified scope
     * List calendars in a Scope at a point in AsAt time.
     * @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.
     */
    listCalendarsInScope(requestParameters?: ListCalendarsInScopeRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<PagedResourceListOfCalendar>;
    listCalendarsInScope(requestParameters?: ListCalendarsInScopeRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<PagedResourceListOfCalendar>>;
    listCalendarsInScope(requestParameters?: ListCalendarsInScopeRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<PagedResourceListOfCalendar>>;
    /**
     * [EARLY ACCESS] UpdateCalendar: Update a calendar
     * Update the calendars WeekendMask, SourceProvider or Properties
     * @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.
     */
    updateCalendar(requestParameters?: UpdateCalendarRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<Calendar>;
    updateCalendar(requestParameters?: UpdateCalendarRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<Calendar>>;
    updateCalendar(requestParameters?: UpdateCalendarRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<Calendar>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarsService, [null, { optional: true; }, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CalendarsService>;
}