@zxncij2390/monorepo3 3.18.0

package/packages/graph/behaviors/telemetry.ts

@@ -0,0 +1,19 @@
+import { TimelinePipe } from "@pnp/core";
+import { Queryable } from "@pnp/queryable";
+
+export function Telemetry(): TimelinePipe<Queryable> {
+
+    return (instance: Queryable) => {
+
+        instance.on.pre(async function (this: Queryable, url, init, result) {
+
+            init.headers = { ...init.headers, SdkVersion: "PnPCoreJS/$$Version$$" };
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion, @typescript-eslint/dot-notation
+            this.log(`Request Tag: ${init.headers!["SdkVersion"]}`, 0);
+
+            return [url, init, result];
+        });
+
+        return instance;
+    };
+}

package/packages/graph/bookings/funcs.ts

@@ -0,0 +1,18 @@
+
+import { IGraphQueryable, GraphQueryableCollection, IGraphQueryableCollection } from "../graphqueryable.js";
+import { BookingAppointment as IBookingAppointmentEntity } from "@microsoft/microsoft-graph-types";
+
+/**
+ * Get the collection of bookingAppointment objects for a bookingBusiness, that occurs in the specified date range.
+ *
+ * @param this IGraphQueryable instance
+ * @param start start time
+ * @param end end time
+ */
+export function calendarView(this: IGraphQueryable, start: string, end: string): IGraphQueryableCollection<IBookingAppointmentEntity[]> {
+
+    const query = GraphQueryableCollection(this, "calendarView");
+    query.query.set("startDateTime", start);
+    query.query.set("endDateTime", end);
+    return query;
+}

package/packages/graph/bookings/index.ts

@@ -0,0 +1,62 @@
+import { BookingBusinesses, BookingCurrencies, IBookingBusinesses, IBookingCurrencies } from "./types.js";
+import { GraphFI } from "../fi.js";
+
+export {
+    BookingCurrencies,
+    BookingCurrency,
+    BookingBusinesses,
+    BookingBusiness,
+    BookingAppointments,
+    BookingAppointment,
+    BookingCustomers,
+    BookingCustomer,
+    BookingServices,
+    BookingService,
+    BookingStaffMembers,
+    BookingStaffMember,
+    BookingCustomQuestions,
+    BookingCustomQuestion,
+    IBookingBusinessAddResult,
+    IBookingAppointmentAddResult,
+    IBookingCustomerAddResult,
+    IBookingServiceAddResult,
+    IBookingStaffMemberAddResult,
+    IBookingCustomQuestionAddResult,
+    IBookingCurrencies,
+    IBookingCurrency,
+    IBookingBusinesses,
+    IBookingBusiness,
+    IBookingAppointments,
+    IBookingAppointment,
+    IBookingCustomers,
+    IBookingCustomer,
+    IBookingServices,
+    IBookingService,
+    IBookingStaffMembers,
+    IBookingStaffMember,
+    IBookingCustomQuestions,
+    IBookingCustomQuestion,
+} from "./types.js";
+
+declare module "../fi" {
+    interface GraphFI {
+        readonly bookingBusinesses: IBookingBusinesses;
+        readonly bookingCurrencies: IBookingCurrencies;
+    }
+}
+
+Reflect.defineProperty(GraphFI.prototype, "bookingBusinesses", {
+    configurable: true,
+    enumerable: true,
+    get: function (this: GraphFI) {
+        return this.create(BookingBusinesses);
+    },
+});
+
+Reflect.defineProperty(GraphFI.prototype, "bookingCurrencies", {
+    configurable: true,
+    enumerable: true,
+    get: function (this: GraphFI) {
+        return this.create(BookingCurrencies);
+    },
+});

package/packages/graph/bookings/types.ts

@@ -0,0 +1,352 @@
+import {
+    BookingBusiness as IBookingBusinessEntity,
+    BookingAppointment as IBookingAppointmentEntity,
+    BookingCustomer as IBookingCustomerEntity,
+    BookingService as IBookingServiceEntity,
+    BookingStaffMember as IBookingStaffMemberEntity,
+    BookingCurrency as IBookingCurrencyEntity,
+    BookingCustomQuestion as IBookingCustomQuestionEntity,
+} from "@microsoft/microsoft-graph-types";
+import { _GraphQueryableCollection, graphInvokableFactory, _GraphQueryableInstance } from "../graphqueryable.js";
+import { defaultPath, deleteable, IDeleteable, updateable, IUpdateable, getById, IGetById } from "../decorators.js";
+import { graphPost } from "../operations.js";
+import { body } from "@pnp/queryable";
+import { calendarView } from "./funcs.js";
+
+/**
+ * Describes a Booking Currency entity
+ *
+ */
+export class _BookingCurrency extends _GraphQueryableInstance<IBookingCurrencyEntity> { }
+export interface IBookingCurrency extends _BookingCurrency { }
+export const BookingCurrency = graphInvokableFactory<IBookingCurrency>(_BookingCurrency);
+
+/**
+ * Describes a collection of Booking Currency objects
+ *
+ */
+@defaultPath("solutions/bookingCurrencies")
+@getById(BookingCurrency)
+export class _BookingCurrencies extends _GraphQueryableCollection<IBookingCurrencyEntity[]>{ }
+export interface IBookingCurrencies extends _BookingCurrencies, IGetById<IBookingCurrency> { }
+export const BookingCurrencies = graphInvokableFactory<IBookingCurrencies>(_BookingCurrencies);
+
+/**
+ * Represents a booking business entity
+ */
+@deleteable()
+@updateable()
+export class _BookingBusiness extends _GraphQueryableInstance<IBookingBusinessEntity> {
+    /**
+     * Get the calendar view for the booking business.
+     */
+    public calendarView = calendarView;
+
+    /**
+     * Make the scheduling page of a business available to external customers.
+     */
+    public publish(): Promise<void> {
+        return graphPost(BookingBusiness(this, "publish"));
+    }
+    /**
+     * Make the scheduling page of this business not available to external customers.
+     */
+    public unpublish(): Promise<void> {
+        return graphPost(BookingBusiness(this, "unpublish"));
+    }
+
+    /**
+     * Get the appointments for the booking business.
+     */
+    public get appointments(): IBookingAppointments {
+        return BookingAppointments(this);
+    }
+
+    /**
+     * Get the customers for the booking business.
+     */
+    public get customers(): IBookingCustomers {
+        return BookingCustomers(this);
+    }
+
+    /**
+     * Get the services for the booking business.
+     */
+    public get services(): IBookingServices {
+        return BookingServices(this);
+    }
+
+    /**
+     * Get the staff members for the booking business.
+     */
+    public get staffMembers(): IBookingStaffMembers {
+        return BookingStaffMembers(this);
+    }
+
+    /**
+     * Get the staff members for the booking business.
+     */
+    public get customQuestions(): IBookingCustomQuestions {
+        return BookingCustomQuestions(this);
+    }
+}
+export interface IBookingBusiness extends _BookingBusiness, IDeleteable, IUpdateable { }
+export const BookingBusiness = graphInvokableFactory<IBookingBusiness>(_BookingBusiness);
+
+/**
+ * Describes a collection of Booking Business objects
+ *
+ */
+@defaultPath("solutions/bookingBusinesses")
+@getById(BookingBusiness)
+export class _BookingBusinesses extends _GraphQueryableCollection<IBookingBusinessEntity[]>{
+    /**
+         * Create a new booking business as specified in the request body.
+         *
+         * @param name The name of the business, which interfaces with customers. This name appears at the top of the business scheduling page.
+         * @param additionalProperties A plain object collection of additional properties you want to set on the new group of type IBookingBusiness
+         */
+    public async add(name: string, additionalProperties: Record<string, any> = {}): Promise<IBookingBusinessAddResult> {
+
+        const postBody = {
+            displayName: name,
+            ...additionalProperties,
+        };
+
+        const data = await graphPost(this, body(postBody));
+
+        return {
+            data,
+            bookingBusiness: (<any>this).getById(data.id),
+        };
+    }
+}
+
+export interface IBookingBusinesses extends _BookingBusinesses, IGetById<IBookingBusiness> { }
+export const BookingBusinesses = graphInvokableFactory<IBookingBusinesses>(_BookingBusinesses);
+
+/**
+ * Represents a booking appointment entity
+ */
+@deleteable()
+@updateable()
+export class _BookingApointment extends _GraphQueryableInstance<IBookingAppointmentEntity> {
+    /**
+     * Cancel the specified bookingAppointment in the specified bookingBusiness and send a message to the involved customer and staff members.
+     */
+    public cancel(cancellationMessage: string): Promise<void> {
+        const postBody = { cancellationMessage };
+        return graphPost(BookingAppointment(this, "cancel"), body(postBody));
+    }
+}
+export interface IBookingAppointment extends _BookingApointment, IDeleteable, IUpdateable { }
+export const BookingAppointment = graphInvokableFactory<IBookingAppointment>(_BookingApointment);
+
+/**
+ * Describes a collection of booking appointment objects
+ *
+ */
+@defaultPath("appointments")
+@getById(BookingAppointment)
+export class _BookingAppointments extends _GraphQueryableCollection<IBookingAppointmentEntity[]>{
+    /**
+     * Create a new booking appointment as specified in the request body.
+     *
+     * @param bookingAppointment  a JSON representation of a BookingAppointment object.
+     */
+    public async add(bookingAppointment: IBookingAppointmentEntity): Promise<IBookingAppointmentAddResult> {
+        const data = await graphPost(this, body(bookingAppointment));
+
+        return {
+            data,
+            bookingAppointment: (<any>this).getById(data.id),
+        };
+    }
+}
+
+export interface IBookingAppointments extends _BookingAppointments, IGetById<IBookingAppointment> { }
+export const BookingAppointments = graphInvokableFactory<IBookingAppointments>(_BookingAppointments);
+
+/**
+ * Represents a booking customer entity
+ */
+@deleteable()
+@updateable()
+export class _BookingCustomer extends _GraphQueryableInstance<IBookingCustomerEntity> { }
+export interface IBookingCustomer extends _BookingCustomer, IDeleteable, IUpdateable { }
+export const BookingCustomer = graphInvokableFactory<IBookingCustomer>(_BookingCustomer);
+
+/**
+ * Describes a collection of booking customer objects
+ *
+ */
+@defaultPath("customers")
+@getById(BookingCustomer)
+export class _BookingCustomers extends _GraphQueryableCollection<IBookingCustomerEntity[]>{
+    /**
+     * Create a new booking customer as specified in the request body.
+     *
+     * @param bookingCustomer  a JSON representation of a BookingCustomer object.
+     */
+    public async add(bookingCustomer: IBookingCustomerEntity): Promise<IBookingCustomerAddResult> {
+        const data = await graphPost(this, body(bookingCustomer));
+
+        return {
+            data,
+            bookingCustomer: (<any>this).getById(data.id),
+        };
+    }
+}
+
+export interface IBookingCustomers extends _BookingCustomers, IGetById<IBookingCustomer> { }
+export const BookingCustomers = graphInvokableFactory<IBookingCustomers>(_BookingCustomers);
+
+/**
+ * Represents a booking service entity
+ */
+@deleteable()
+@updateable()
+export class _BookingService extends _GraphQueryableInstance<IBookingServiceEntity> { }
+export interface IBookingService extends _BookingService, IDeleteable, IUpdateable { }
+export const BookingService = graphInvokableFactory<IBookingService>(_BookingService);
+
+/**
+ * Describes a collection of booking service objects
+ *
+ */
+@defaultPath("services")
+@getById(BookingService)
+export class _BookingServices extends _GraphQueryableCollection<IBookingServiceEntity[]>{
+    /**
+     * Create a new booking service as specified in the request body.
+     *
+     * @param bookingService  a JSON representation of a BookingService object.
+     */
+    public async add(bookingService: IBookingServiceEntity): Promise<IBookingServiceAddResult> {
+        const data = await graphPost(this, body(bookingService));
+
+        return {
+            data,
+            bookingService: (<any>this).getById(data.id),
+        };
+    }
+}
+
+export interface IBookingServices extends _BookingServices, IGetById<IBookingService> { }
+export const BookingServices = graphInvokableFactory<IBookingServices>(_BookingServices);
+
+/**
+ * Represents a booking staffmember entity
+ */
+@deleteable()
+@updateable()
+export class _BookingStaffMember extends _GraphQueryableInstance<IBookingStaffMemberEntity> { }
+export interface IBookingStaffMember extends _BookingStaffMember, IDeleteable, IUpdateable { }
+export const BookingStaffMember = graphInvokableFactory<IBookingStaffMember>(_BookingStaffMember);
+
+/**
+ * Describes a collection of booking staffmember objects
+ *
+ */
+@defaultPath("staffMembers")
+@getById(BookingStaffMember)
+export class _BookingStaffMembers extends _GraphQueryableCollection<IBookingStaffMemberEntity[]>{
+    /**
+     * Create a new booking staffmember as specified in the request body.
+     *
+     * @param bookingStaffMember  a JSON representation of a BookingStaffMember object.
+     */
+    public async add(bookingStaffMember: IBookingStaffMemberEntity): Promise<IBookingStaffMemberAddResult> {
+        const data = await graphPost(this, body(bookingStaffMember));
+
+        return {
+            data,
+            bookingStaffMember: (<any>this).getById(data.id),
+        };
+    }
+}
+
+export interface IBookingStaffMembers extends _BookingStaffMembers, IGetById<IBookingStaffMember> { }
+export const BookingStaffMembers = graphInvokableFactory<IBookingStaffMembers>(_BookingStaffMembers);
+
+/**
+ * Represents a booking custom questions entity
+ */
+@deleteable()
+@updateable()
+export class _BookingCustomQuestion extends _GraphQueryableInstance<IBookingCustomQuestionEntity> { }
+export interface IBookingCustomQuestion extends _BookingCustomQuestion, IDeleteable, IUpdateable { }
+export const BookingCustomQuestion = graphInvokableFactory<IBookingCustomQuestion>(_BookingCustomQuestion);
+
+/**
+ * Describes a collection of booking custom questions objects
+ *
+ */
+@defaultPath("customquestions")
+@getById(BookingCustomQuestion)
+export class _BookingCustomQuestions extends _GraphQueryableCollection<IBookingCustomQuestionEntity[]>{
+    /**
+     * Create a new booking customquestions as specified in the request body.
+     *
+     * @param bookingCustomQuestion  a JSON representation of a BookingCustomQuestion object.
+     */
+    public async add(bookingCustomQuestion: IBookingCustomQuestionEntity): Promise<IBookingCustomQuestionAddResult> {
+        const data = await graphPost(this, body(bookingCustomQuestion));
+
+        return {
+            data,
+            bookingCustomQuestion: (<any>this).getById(data.id),
+        };
+    }
+}
+
+export interface IBookingCustomQuestions extends _BookingCustomQuestions, IGetById<IBookingCustomQuestion> { }
+export const BookingCustomQuestions = graphInvokableFactory<IBookingCustomQuestions>(_BookingCustomQuestions);
+
+/**
+ * IBookingBusinessAddResult
+ */
+export interface IBookingBusinessAddResult {
+    bookingBusiness: IBookingBusinessEntity;
+    data: any;
+}
+
+/**
+ * IBookingAppointmentAddResult
+ */
+export interface IBookingAppointmentAddResult {
+    bookingAppointment: IBookingAppointmentEntity;
+    data: any;
+}
+
+/**
+ * IBookingCustomerAddResult
+ */
+export interface IBookingCustomerAddResult {
+    bookingCustomer: IBookingCustomerEntity;
+    data: any;
+}
+
+/**
+ * IBookingServiceAddResult
+ */
+export interface IBookingServiceAddResult {
+    bookingService: IBookingServiceEntity;
+    data: any;
+}
+
+/**
+ * IBookingStaffMemberAddResult
+ */
+export interface IBookingStaffMemberAddResult {
+    bookingStaffMember: IBookingStaffMemberEntity;
+    data: any;
+}
+
+/**
+ * IBookingCustomQuestionAddResult
+ */
+export interface IBookingCustomQuestionAddResult {
+    bookingCustomQuestion: IBookingCustomQuestionEntity;
+    data: any;
+}

package/packages/graph/calendars/funcs.ts

@@ -0,0 +1,58 @@
+import { IGraphQueryable, GraphQueryableCollection, IGraphQueryableCollection } from "../graphqueryable.js";
+import { EmailAddress, Event as IEvent } from "@microsoft/microsoft-graph-types";
+import { Endpoint } from "../behaviors/endpoint.js";
+
+interface IEventWithTag extends IEvent {
+    "@odata.etag": string;
+}
+
+/**
+ * Get the occurrences, exceptions, and single instances of events in a calendar view defined by a time range,
+ * from the user's default calendar, or from some other calendar of the user's
+ *
+ * @param this IGraphQueryable instance
+ * @param start start time
+ * @param end end time
+ */
+export function calendarView(this: IGraphQueryable, start: string, end: string): IGraphQueryableCollection<ICalendarViewInfo[]> {
+
+    const query = GraphQueryableCollection(this, "calendarView");
+    query.query.set("startDateTime", start);
+    query.query.set("endDateTime", end);
+    return query;
+}
+
+export type ICalendarViewInfo = IEventWithTag;
+
+/**
+ * Get the emailAddress objects that represent all the meeting rooms in the user's tenant or in a specific room list.
+ *  - This is a beta graph feature and uses the beta endpoint.
+ *
+ * @param this IGraphQueryable instance
+ * @param roomList The SMTP address associated with the room list.
+ */
+export function findRooms(this: IGraphQueryable, roomList?: string): IGraphQueryableCollection<EmailAddress[]> {
+    const query = GraphQueryableCollection(this, roomList ? "findRooms(RoomList=@roomList)" : "findRooms");
+    query.using(Endpoint("beta"));
+    if (roomList) {
+        query.query.set("@roomList", `'${roomList}'`);
+    }
+    return query;
+}
+
+/**
+ * Get the instances (occurrences) of an event for a specified time range.
+ * If the event is a seriesMaster type, this returns the occurrences and exceptions of the event in the specified time range.
+ *
+ * @param this IGraphQueryable instance
+ * @param start start time
+ * @param end end time
+ */
+export function instances(this: IGraphQueryable, start: string, end: string): IGraphQueryableCollection<IInstance[]> {
+    const query = GraphQueryableCollection(this, "instances");
+    query.query.set("startDateTime", start);
+    query.query.set("endDateTime", end);
+    return query;
+}
+
+export type IInstance = IEventWithTag;

package/packages/graph/calendars/groups.ts

@@ -0,0 +1,19 @@
+import { addProp } from "@pnp/queryable";
+import { _Group } from "../groups/types.js";
+import { Calendar, ICalendar, IEvents, Events } from "./types.js";
+
+declare module "../groups/types" {
+    interface _Group {
+        readonly calendar: ICalendar;
+        readonly attachmentFiles: ICalendar;
+        readonly events: IEvents;
+    }
+    interface IGroup {
+        readonly calendar: ICalendar;
+        readonly attachmentFiles: ICalendar;
+        readonly events: IEvents;
+    }
+}
+
+addProp(_Group, "calendar", Calendar);
+addProp(_Group, "events", Events);

package/packages/graph/calendars/index.ts

@@ -0,0 +1,18 @@
+import "./groups.js";
+import "./users.js";
+
+export {
+    Calendar,
+    Calendars,
+    Event,
+    IEventAddResult,
+    Events,
+    ICalendar,
+    ICalendars,
+    IEvent,
+    IEvents,
+} from "./types.js";
+
+export {
+    ICalendarViewInfo,
+} from "./funcs.js";

package/packages/graph/calendars/types.ts

@@ -0,0 +1,73 @@
+import { body } from "@pnp/queryable";
+import { Event as IEventType, Calendar as ICalendarType } from "@microsoft/microsoft-graph-types";
+import { _GraphQueryableCollection, _GraphQueryableInstance, graphInvokableFactory } from "../graphqueryable.js";
+import { defaultPath, IDeleteable, deleteable, IUpdateable, updateable, getById, IGetById } from "../decorators.js";
+import { graphPost } from "../operations.js";
+import { calendarView, instances } from "./funcs.js";
+
+/**
+ * Calendar
+ */
+export class _Calendar extends _GraphQueryableInstance<ICalendarType> {
+
+    public get events(): IEvents {
+        return Events(this);
+    }
+
+    public calendarView = calendarView;
+}
+export interface ICalendar extends _Calendar { }
+export const Calendar = graphInvokableFactory<ICalendar>(_Calendar);
+
+/**
+ * Calendars
+ */
+@defaultPath("calendars")
+@getById(Calendar)
+export class _Calendars extends _GraphQueryableCollection<ICalendarType[]> { }
+export interface ICalendars extends _Calendars, IGetById<ICalendar> { }
+export const Calendars = graphInvokableFactory<ICalendars>(_Calendars);
+
+/**
+ * Event
+ */
+@deleteable()
+@updateable()
+export class _Event extends _GraphQueryableInstance<IEventType> {
+    public instances = instances;
+}
+export interface IEvent extends _Event, IDeleteable, IUpdateable { }
+export const Event = graphInvokableFactory<IEvent>(_Event);
+
+/**
+ * Events
+ */
+@defaultPath("events")
+@getById(Event)
+export class _Events extends _GraphQueryableCollection<IEventType[]> {
+
+    /**
+     * Adds a new event to the collection
+     *
+     * @param properties The set of properties used to create the event
+     */
+    public async add(properties: IEventType): Promise<IEventAddResult> {
+
+        const data = await graphPost(this, body(properties));
+
+        return {
+            data,
+            event: (<any>this).getById(data.id),
+        };
+    }
+}
+export interface IEvents extends _Events, IGetById<IEvent> { }
+export const Events = graphInvokableFactory<IEvents>(_Events);
+
+/**
+ * EventAddResult
+ */
+export interface IEventAddResult {
+    data: IEventType;
+    event: IEvent;
+}

package/packages/graph/calendars/users.ts

@@ -0,0 +1,28 @@
+import { addProp } from "@pnp/queryable";
+import { _User } from "../users/types.js";
+import { Calendar, ICalendar, IEvents, Events, Calendars, ICalendars } from "./types.js";
+import { calendarView, ICalendarViewInfo } from "./funcs.js";
+import { IGraphQueryableCollection } from "../graphqueryable.js";
+
+declare module "../users/types" {
+    interface _User {
+        readonly calendar: ICalendar;
+        readonly calendars: ICalendars;
+        readonly attachmentFiles: ICalendar;
+        readonly events: IEvents;
+        calendarView(start: string, end: string): IGraphQueryableCollection<ICalendarViewInfo[]>;
+    }
+    interface IUser {
+        readonly calendar: ICalendar;
+        readonly calendars: ICalendars;
+        readonly attachmentFiles: ICalendar;
+        readonly events: IEvents;
+        calendarView(start: string, end: string): IGraphQueryableCollection<ICalendarViewInfo[]>;
+    }
+}
+
+addProp(_User, "calendar", Calendar);
+addProp(_User, "calendars", Calendars);
+addProp(_User, "events", Events);
+
+_User.prototype.calendarView = calendarView;

package/packages/graph/cloud-communications/index.ts

@@ -0,0 +1,24 @@
+import { GraphFI } from "../fi.js";
+import { Communications, ICommunications } from "./types.js";
+import "./users.js";
+
+export {
+    Presence,
+    IPresence,
+    Communications,
+    ICommunications,
+} from "./types.js";
+
+declare module "../fi" {
+    interface GraphFI {
+        readonly communications: ICommunications;
+    }
+}
+
+Reflect.defineProperty(GraphFI.prototype, "communications", {
+    configurable: true,
+    enumerable: true,
+    get: function (this: GraphFI) {
+        return this.create(Communications);
+    },
+});