@nylas/web-elements 1.0.0-prealpha1

package/dist/types/components/scheduler/nylas-booked-event-card/nylas-booked-event-card.d.ts

@@ -0,0 +1,22 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+import { NylasSchedulerBookingData } from '../../..';
+import '@spectrum-web-components/icons-workflow/icons/sp-icon-chevron-left';
+import { NylasEvent } from "../../../common/types";
+export declare class NylasBookedEventCard {
+    readonly eventInfo: NylasEvent;
+    readonly bookingFlow: 'booking' | 'rescheduling';
+    readonly bookingInfo?: NylasSchedulerBookingData;
+    readonly cancelBookingButtonClicked: EventEmitter<{
+        bookingId: string;
+    }>;
+    readonly rescheduleButtonClicked: EventEmitter<{
+        bookingId: string;
+    }>;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    componentWillLoad(): Promise<void>;
+    componentDidLoad(): Promise<void>;
+    private handleCancelBookingButtonClicked;
+    private handleRescheduleButtonClicked;
+    render(): any;
+}

package/dist/types/components/scheduler/nylas-booking-form/nylas-booking-form.d.ts

@@ -0,0 +1,33 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+import '@spectrum-web-components/icons-workflow/icons/sp-icon-add-circle';
+import '@spectrum-web-components/icons-workflow/icons/sp-icon-remove-circle';
+import { NylasErrorResponse } from '../../..';
+import type { NylasEvent, NylasSchedulerBookingData } from '../../..';
+export declare class NylasBookingForm {
+    readonly host: HTMLElement;
+    readonly bookedEventLoading?: boolean;
+    readonly bookedEventError?: NylasErrorResponse;
+    readonly bookingInfo?: NylasSchedulerBookingData;
+    readonly eventInfo?: NylasEvent;
+    nameChanged: EventEmitter<string>;
+    emailChanged: EventEmitter<string>;
+    backButtonClicked: EventEmitter<boolean>;
+    detailsConfirmed: EventEmitter<NylasSchedulerBookingData>;
+    name: string;
+    email: string;
+    guestEmails: string[];
+    isNameValid: boolean;
+    isEmailValid: boolean;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    componentWillLoad(): void;
+    bookingInfoChangedHandler(newValue: NylasSchedulerBookingData | undefined): void;
+    private changeName;
+    private changeEmail;
+    private handleGuestChange;
+    private addGuestButtonClickedHandler;
+    private removeGuestButtonClickHandler;
+    private handleBackButtonClicked;
+    private bookButtonClickedHandler;
+    render(): any;
+}

package/dist/types/components/scheduler/nylas-cancelled-event-card/nylas-cancelled-event-card.d.ts

@@ -0,0 +1,13 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+import { NylasEvent } from '../../..';
+import '@spectrum-web-components/icons-workflow/icons/sp-icon-chevron-left';
+export declare class NylasCancelledEventCard {
+    readonly cancelledEvent: NylasEvent;
+    readonly closeCancelEventCardClicked: EventEmitter<void>;
+    connectedCallback(): void;
+    componentWillLoad(): Promise<void>;
+    componentDidLoad(): Promise<void>;
+    disconnectedCallback(): void;
+    private handleCloseClicked;
+    render(): any;
+}

package/dist/types/components/scheduler/nylas-date-picker/nylas-date-picker.d.ts

@@ -0,0 +1,19 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+import { LoadingState } from '../../..';
+export declare class NylasDatePicker {
+    selectableDates?: Date[];
+    selectedDate?: Date;
+    readonly loadingState?: LoadingState;
+    month: Date;
+    dates: Date[];
+    dateSelected: EventEmitter<Date>;
+    monthChanged: EventEmitter<Date>;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    componentWillLoad(): void;
+    private getDates;
+    private selectDate;
+    private changeMonth;
+    private isSelected;
+    render(): any;
+}

package/dist/types/components/scheduler/nylas-locale-switch/nylas-locale-switch.d.ts

@@ -0,0 +1,13 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+export declare class NylasLocaleSwitch {
+    selectedTimezone: string;
+    selectedLanguage: string;
+    timezoneChanged: EventEmitter<string>;
+    languageChanged: EventEmitter<string>;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    componentWillLoad(): void;
+    private changeTimezone;
+    private changeLanguage;
+    render(): any;
+}

package/dist/types/components/scheduler/nylas-notification/nylas-notification.d.ts

@@ -0,0 +1,13 @@
+import { Notification } from '@nylas/core';
+export declare class NylasNotification {
+    ttl: number;
+    allowedCategories: string[];
+    notifications: Notification[];
+    onError(event: CustomEvent<Notification>): void;
+    onWarning(event: CustomEvent<Notification>): void;
+    onInfo(event: CustomEvent<Notification>): void;
+    onSuccess(event: CustomEvent<Notification>): void;
+    private handleNotification;
+    private dismissNotification;
+    render(): any;
+}

package/dist/types/components/scheduler/nylas-open-hours-picker/nylas-open-hours-picker.d.ts

@@ -0,0 +1,40 @@
+import { OpenHour } from '@nylas/core';
+import { EventEmitter } from '../../../stencil-public-runtime';
+export declare class NylasOpenHoursPicker {
+    host: HTMLElement;
+    readonly openHours: OpenHour[];
+    startTime: Date;
+    endTime: Date;
+    stepMinutes: number;
+    dragThreshold: number;
+    readonly mobileViewPortWidth: number;
+    private intervalMinutes;
+    private times;
+    private availableTimes;
+    private draggingStartDate;
+    private draggingEndDate;
+    private inverse;
+    private isMobile;
+    readonly openHoursChanged: EventEmitter<OpenHour[]>;
+    private dragStartTime;
+    componentWillLoad(): void;
+    whenOpenHoursChanged(newValue: OpenHour[], oldValue: OpenHour[]): void;
+    availableTimesChanged(): void;
+    inverseChanged(): void;
+    onResize(): void;
+    private onSelectedHoursWeel;
+    private onContextMenu;
+    private onMouseDown;
+    private onMouseOver;
+    private onMouseUp;
+    private onTimeClick;
+    private isDragging;
+    private updateAvailableTimes;
+    private isAvailableTime;
+    private getSelectedDate;
+    private isHovering;
+    private calculateAvailableTimes;
+    private calculateOpenHours;
+    private getNumberOfDatesBetween;
+    render(): any;
+}

package/dist/types/components/scheduler/nylas-scheduler/nylas-scheduler.d.ts

@@ -0,0 +1,41 @@
+import { RegisteredComponent } from "../../../common/register-component";
+import type { SchedulerEventOverride } from "../../../common/component-types";
+import { NylasSchedulerConnector } from "../../../connector/nylas-scheduler-connector/index";
+import { LoadingState, NylasSchedulerStoreState, NylasSchedulerStoreType } from "../../../stores/scheduler-store";
+import { NylasSchedulerBookingData, ThemeConfig, Notification } from '@nylas/core';
+import { EventEmitter } from '../../../stencil-public-runtime';
+export declare class NylasScheduler {
+    private stores?;
+    private baseProvider?;
+    private nylasSchedulerConnector?;
+    private host;
+    readonly mode: 'app' | 'composable';
+    readonly defaultSchedulerStoreState?: NylasSchedulerStoreState;
+    readonly sessionId?: string;
+    readonly schedulerApiUrl: string;
+    readonly bookingInfo?: NylasSchedulerBookingData;
+    readonly rescheduleId?: string;
+    readonly eventOverrides: SchedulerEventOverride;
+    readonly loadingState?: LoadingState;
+    readonly themeConfig?: ThemeConfig;
+    automaticComponentRegistration: boolean;
+    selectedDateLabel: string;
+    init: EventEmitter<HTMLNylasSchedulerElement>;
+    nylasSchedulerError: EventEmitter<Notification>;
+    connectedCallback(): void;
+    componentWillLoad(): Promise<void>;
+    componentDidLoad(): Promise<void>;
+    componentDisconnected(): void;
+    bookingInfoChanged(newVal?: NylasSchedulerBookingData): void;
+    registerComponentHandler(event: CustomEvent<RegisteredComponent<any, any>>): Promise<void>;
+    unregisterComponentHandler(event: CustomEvent<RegisteredComponent<any, any>>): Promise<void>;
+    monthChangedHandler(event: CustomEvent<Date>): Promise<void>;
+    bookButtonClickedHandler(event: CustomEvent<NylasSchedulerBookingData>): Promise<void>;
+    cancelButtonClickedHandler(): Promise<void>;
+    selectedDateChanged(event: CustomEvent<Date>): void;
+    getNylasSchedulerStore(): Promise<NylasSchedulerStoreType | undefined>;
+    getNylasSchedulerConnector(): Promise<NylasSchedulerConnector | undefined>;
+    getRef(): Promise<HTMLNylasSchedulerElement>;
+    private getErrorObject;
+    render(): any;
+}

package/dist/types/components/scheduler/nylas-scheduler/scheduler-view.d.ts

@@ -0,0 +1,6 @@
+import { FunctionalComponent } from '../../../stencil-public-runtime';
+import { LoadingState } from '../../../components';
+export type SchedulerViewProps = {
+    loadingState?: LoadingState;
+};
+export declare const SchedulerView: FunctionalComponent<SchedulerViewProps>;

package/dist/types/components/scheduler/nylas-selected-event-card/nylas-selected-event-card.d.ts

@@ -0,0 +1,15 @@
+import type { Timeslot } from '@nylas/core';
+import '@spectrum-web-components/icons-workflow/icons/sp-icon-chevron-left';
+export declare class NylasSelectedEventCard {
+    readonly selectedDate?: Date;
+    readonly selectedTimeslot?: Timeslot;
+    readonly selectedTimezone: string;
+    startTime: string;
+    endTime: string;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    componentWillLoad(): Promise<void>;
+    componentDidLoad(): Promise<void>;
+    handleSelectedTimeslotChange(selectedTimeslot: Timeslot): void;
+    render(): any;
+}

package/dist/types/components/scheduler/nylas-timeslot-picker/nylas-timeslot-picker.d.ts

@@ -0,0 +1,28 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+import { AvailabilityTimeslot, LoadingState } from "../../../stores/scheduler-store";
+import type { Timeslot } from '@nylas/core';
+export declare class NylasTimeslotPicker {
+    readonly selectedDate?: Date;
+    readonly availability?: AvailabilityTimeslot[];
+    readonly selectedTimeslot?: Timeslot;
+    readonly loadingState?: LoadingState;
+    readonly selectedTimezone: string;
+    readonly timeslotSelected: EventEmitter<Timeslot>;
+    readonly timeslotConfirmed: EventEmitter<Timeslot>;
+    times: AvailabilityTimeslot[];
+    hoveredTimeslotIndex?: number;
+    selectedTimeslotIndex?: string;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    componentWillLoad(): Promise<void>;
+    componentDidLoad(): Promise<void>;
+    private getTimeslotId;
+    private onClickSelectTime;
+    private handleConfirmedTimeslot;
+    private handleMouseEnter;
+    private handleMouseLeave;
+    private getTimeSlotLabel;
+    selectedDateChanged(newVal: Date | null | undefined): void;
+    availabilityChanged(newVal: AvailabilityTimeslot[] | undefined): void;
+    render(): any;
+}