@nylas/web-elements 1.0.0-prealpha1

package/dist/types/connector/connector-interface.d.ts

@@ -0,0 +1,35 @@
+import { RouterInterface } from "../routers/router-interface";
+import { NylasAuthType } from '@nylas/core';
+import { NylasAuthStoreType, NylasMailboxStoreType, NylasSchedulerStoreType } from '..';
+import { NylasAuthConnector } from './shared/api/auth';
+import { NylasMessagesConnector } from './shared/api/messages';
+import { NylaSchedulerAPIConnector } from './shared/api/scheduler';
+import { NylasThreadsConnector } from './shared/api/threads';
+import { NylasFoldersConnector } from './shared/api/folders';
+export interface BaseNylasConnectorInterface {
+    resetStores(): void;
+    init(): void;
+}
+export interface NylasAuthConnectorInterface extends BaseNylasConnectorInterface {
+    nylasAuth: NylasAuthType;
+    nylasAuthStore: NylasAuthStoreType;
+    get authStore(): NylasAuthStoreType;
+    get auth(): NylasAuthConnector;
+    logout(): Promise<void>;
+}
+export interface NylasMailboxConnectorInterface extends NylasAuthConnectorInterface {
+    nylasMailboxStore: NylasMailboxStoreType;
+    router: RouterInterface;
+    get mailboxStore(): NylasMailboxStoreType;
+    get threads(): NylasThreadsConnector;
+    get messages(): NylasMessagesConnector;
+    get folders(): NylasFoldersConnector;
+}
+export interface NylasSchedulerConnectorInterface extends BaseNylasConnectorInterface {
+    schedulerAPIURL: string;
+    nylasSchedulerStore: NylasSchedulerStoreType;
+    get schedulerStore(): NylasSchedulerStoreType;
+    get scheduler(): NylaSchedulerAPIConnector;
+}
+export interface NylasConnectorInterface extends NylasAuthConnectorInterface, NylasMailboxConnectorInterface, NylasSchedulerConnectorInterface {
+}

package/dist/types/connector/nylas-connector/index.d.ts

@@ -0,0 +1,59 @@
+import { RouterInterface } from "../../routers/router-interface";
+import { NylasAuthStoreType } from "../../stores/auth-store";
+import { NylasMailboxStoreType } from "../../stores/mailbox-store";
+import { NylasSchedulerStoreType } from "../../stores/scheduler-store";
+import type { NylasAuthType } from '@nylas/core';
+import { NylasConnectorInterface } from '../connector-interface';
+import { NylasAuthConnector } from '../shared/api/auth';
+import { NylasFoldersConnector } from '../shared/api/folders';
+import { NylasMessagesConnector } from '../shared/api/messages';
+import { NylaSchedulerAPIConnector } from '../shared/api/scheduler';
+import { NylasThreadsConnector } from '../shared/api/threads';
+export declare class NylasConnector implements NylasConnectorInterface {
+    router: RouterInterface;
+    nylasAuth: NylasAuthType;
+    nylasAuthStore: NylasAuthStoreType;
+    nylasMailboxStore: NylasMailboxStoreType;
+    nylasSchedulerStore: NylasSchedulerStoreType;
+    schedulerAPIURL: string;
+    private _authConnector;
+    private _threadConnector;
+    private _messageConnector;
+    private _schedulerAPIConnector;
+    private _foldersConnector;
+    constructor(router: RouterInterface, nylasAuth: NylasAuthType, nylasAuthStore: NylasAuthStoreType, nylasMailboxStore: NylasMailboxStoreType, nylasSchedulerStore: NylasSchedulerStoreType, schedulerAPIURL?: string);
+    init(): void;
+    get authStore(): import("@stencil/store").ObservableMap<import("@/stores/auth-store").NylasAuthStoreState>;
+    get mailboxStore(): import("@stencil/store").ObservableMap<import("@/stores/mailbox-store").NylasMailboxStoreState>;
+    get schedulerStore(): import("@stencil/store").ObservableMap<import("@/stores/scheduler-store").NylasSchedulerStoreState>;
+    get auth(): NylasAuthConnector;
+    get threads(): NylasThreadsConnector;
+    get messages(): NylasMessagesConnector;
+    get folders(): NylasFoldersConnector;
+    get scheduler(): NylaSchedulerAPIConnector;
+    getAuth(): {
+        config: import("@nylas/core").AuthConfg;
+        getHostedAuthRedirectURL(scopes?: string[] | undefined, email?: string | undefined, provider?: string | undefined): Promise<string>;
+        nylasAPIRequest: {
+            <T>(path: string, method?: string | undefined, body?: any, parseJSON?: boolean | undefined, domain?: string | undefined, request?: RequestInit | undefined): Promise<T>;
+            <T_1>(path: string, method: string, body: any, parseJSON: false, domain?: string | undefined, request?: RequestInit | undefined): Promise<ReadableStream<Uint8Array> | null>;
+            <T_2>(path: string, method: string, body: any, parseJSON: true, domain?: string | undefined, request?: RequestInit | undefined): Promise<T_2>;
+            <T_3>(path: string, method: string, body: any, parseJSON: boolean, domain?: string | undefined, request?: RequestInit | undefined): Promise<T_3 | ReadableStream<Uint8Array> | null>;
+        };
+        exchangeAuthCodeForTokenInfo(code: string): Promise<import("@nylas/core").TokenExchangeResponse | null>;
+        nylasDownloadFileRequest(path: string, method?: string | undefined, body?: any): Promise<Blob>;
+        logout(): Promise<void>;
+        isAuthenticated(): Promise<boolean>;
+        getTokenInfo(): Promise<import("@nylas/core/dist/auth").TokenInfo | null>;
+        isAccessTokenValid(): Promise<boolean>;
+        refreshAccessToken(): Promise<import("@nylas/core").TokenExchangeResponse | null>;
+        hasScopeByType(service: "email" | undefined, types: string | string[]): Promise<boolean>;
+        hasScope(scope: string | string[]): Promise<boolean>;
+    };
+    resetStores(): void;
+    logout(): Promise<void>;
+}
+export type PublicMethods<T> = {
+    [K in keyof T]: T[K] extends Function ? (string extends K ? never : K) : never;
+}[keyof T];
+export type NylasConnectorPublicMethods = PublicMethods<NylasConnector>;

package/dist/types/connector/nylas-mailbox-connector/index.d.ts

@@ -0,0 +1,52 @@
+import { RouterInterface } from "../../routers/router-interface";
+import { NylasAuthStoreType } from "../../stores/auth-store";
+import { NylasMailboxStoreType } from "../../stores/mailbox-store";
+import type { NylasAuthType } from '@nylas/core';
+import { NylasMailboxConnectorInterface } from '../connector-interface';
+import { NylasAuthConnector } from '../shared/api/auth';
+import { NylasMessagesConnector } from '../shared/api/messages';
+import { NylasThreadsConnector } from '../shared/api/threads';
+import { NylasFoldersConnector } from '../shared/api/folders';
+export declare class NylasMailboxConnector implements NylasMailboxConnectorInterface {
+    nylasAuth: NylasAuthType;
+    nylasMailboxStore: NylasMailboxStoreType;
+    nylasAuthStore: NylasAuthStoreType;
+    router: RouterInterface;
+    private _authConnector;
+    private _threadConnector;
+    private _messageConnector;
+    private _foldersConnector;
+    constructor(router: RouterInterface, nylasAuth: NylasAuthType, nylasAuthStore: NylasAuthStoreType, nylasStore: NylasMailboxStoreType);
+    init(): void;
+    get mailboxStore(): import("@stencil/store").ObservableMap<import("@/stores/mailbox-store").NylasMailboxStoreState>;
+    get authStore(): import("@stencil/store").ObservableMap<import("@/stores/auth-store").NylasAuthStoreState>;
+    get auth(): NylasAuthConnector;
+    get threads(): NylasThreadsConnector;
+    get messages(): NylasMessagesConnector;
+    get folders(): NylasFoldersConnector;
+    getAuth(): {
+        config: import("@nylas/core").AuthConfg;
+        getHostedAuthRedirectURL(scopes?: string[] | undefined, email?: string | undefined, provider?: string | undefined): Promise<string>;
+        nylasAPIRequest: {
+            <T>(path: string, method?: string | undefined, body?: any, parseJSON?: boolean | undefined, domain?: string | undefined, request?: RequestInit | undefined): Promise<T>;
+            <T_1>(path: string, method: string, body: any, parseJSON: false, domain?: string | undefined, request?: RequestInit | undefined): Promise<ReadableStream<Uint8Array> | null>;
+            <T_2>(path: string, method: string, body: any, parseJSON: true, domain?: string | undefined, request?: RequestInit | undefined): Promise<T_2>;
+            <T_3>(path: string, method: string, body: any, parseJSON: boolean, domain?: string | undefined, request?: RequestInit | undefined): Promise<T_3 | ReadableStream<Uint8Array> | null>;
+        };
+        exchangeAuthCodeForTokenInfo(code: string): Promise<import("@nylas/core").TokenExchangeResponse | null>;
+        nylasDownloadFileRequest(path: string, method?: string | undefined, body?: any): Promise<Blob>;
+        logout(): Promise<void>;
+        isAuthenticated(): Promise<boolean>;
+        getTokenInfo(): Promise<import("@nylas/core/dist/auth").TokenInfo | null>;
+        isAccessTokenValid(): Promise<boolean>;
+        refreshAccessToken(): Promise<import("@nylas/core").TokenExchangeResponse | null>;
+        hasScopeByType(service: "email" | undefined, types: string | string[]): Promise<boolean>;
+        hasScope(scope: string | string[]): Promise<boolean>;
+    };
+    resetStores(): void;
+    logout(): Promise<void>;
+}
+export type PublicMethods<T> = {
+    [K in keyof T]: T[K] extends Function ? (string extends K ? never : K) : never;
+}[keyof T];
+export type NylasMailboxConnectorPublicMethods = PublicMethods<NylasMailboxConnector>;

package/dist/types/connector/nylas-scheduler-connector/index.d.ts

@@ -0,0 +1,24 @@
+import { NylasSchedulerStoreType } from "../../stores/scheduler-store";
+import { NylasSchedulerConnectorInterface } from '../connector-interface';
+import { NylaSchedulerAPIConnector } from '../shared/api/scheduler';
+type NylasSchedulerConnectorOptions = {
+    schedulerAPIURL: string;
+    nylasSchedulerStore: NylasSchedulerStoreType;
+    sessionId?: string;
+};
+export declare class NylasSchedulerConnector implements NylasSchedulerConnectorInterface {
+    schedulerAPIURL: string;
+    nylasSchedulerStore: NylasSchedulerStoreType;
+    sessionId: string | undefined;
+    private _schedulerAPIConnector;
+    constructor({ schedulerAPIURL, nylasSchedulerStore, sessionId }: NylasSchedulerConnectorOptions);
+    init(): void;
+    get schedulerStore(): import("@stencil/store").ObservableMap<import("@/stores/scheduler-store").NylasSchedulerStoreState>;
+    get scheduler(): NylaSchedulerAPIConnector;
+    resetStores(): void;
+}
+export type PublicMethods<T> = {
+    [K in keyof T]: T[K] extends Function ? (string extends K ? never : K) : never;
+}[keyof T];
+export type NylasSchedulerConnectorPublicMethods = PublicMethods<NylasSchedulerConnector>;
+export {};

package/dist/types/connector/shared/api/auth.d.ts

@@ -0,0 +1,13 @@
+import { NylasAuthStoreType, NylasAuthType, TokenInfo } from '../../..';
+export declare class NylasAuthConnector {
+    private nylasAuth;
+    private nylasAuthStore;
+    constructor(nylasAuth: NylasAuthType, nylasAuthStore: NylasAuthStoreType);
+    validateSession(): Promise<void>;
+    isAuthenticated(): Promise<boolean>;
+    getTokenInfo(): Promise<TokenInfo | null>;
+    isAccessTokenValid(): Promise<boolean>;
+    logout(): Promise<void>;
+    getHostedAuthRedirectURL(scopes?: string[], email?: string, provider?: string): Promise<string>;
+    manageHostedAuthCodeExchange(currentUrl: string): Promise<TokenInfo | null>;
+}

package/dist/types/connector/shared/api/folders.d.ts

@@ -0,0 +1,10 @@
+import { Folder, NylasAuthType } from '@nylas/core';
+import { NylasAuthStoreType, NylasMailboxStoreType } from '../../../components';
+export declare class NylasFoldersConnector {
+    private nylasAuth;
+    private nylasAuthStore;
+    private nylasMailboxStore;
+    constructor(nylasAuth: NylasAuthType, nylasAuthStore: NylasAuthStoreType, nylasMailboxStore: NylasMailboxStoreType);
+    getFolders(): Promise<Folder[]>;
+    selectFolder(folder: Folder): Promise<void>;
+}

package/dist/types/connector/shared/api/messages.d.ts

@@ -0,0 +1,13 @@
+import { Message, NylasAuthType } from '@nylas/core';
+import { NylasAuthStoreType, NylasMailboxStoreType } from '../../../components';
+export declare class NylasMessagesConnector {
+    private nylasAuth;
+    private nylasAuthStore;
+    private nylasMailboxStore;
+    constructor(nylasAuth: NylasAuthType, nylasAuthStore: NylasAuthStoreType, nylasMailboxStore: NylasMailboxStoreType);
+    getMessages(): Promise<Message[]>;
+    getThreadMessages(threadId: string): Promise<Message[]>;
+    downloadMessageAttachments(message: Message): Promise<Blob>[];
+    summarizeText(text: string): Promise<string>;
+    textToSpeech(text: string, abortController?: AbortController): Promise<ReadableStream<Uint8Array> | null>;
+}

package/dist/types/connector/shared/api/scheduler.d.ts

@@ -0,0 +1,29 @@
+import { AvailabilityResponse, NylasEvent } from "../../../common/types";
+import { NylasSchedulerStoreType } from '../../../components';
+import type { NylasResponse, NylasSchedulerBookingData, Timeslot } from '@nylas/core';
+type NylasSchedulerAPIConnectorOptions = {
+    schedulerAPIURL: string;
+    schedulerStore: NylasSchedulerStoreType;
+    sessionId?: string;
+};
+export declare class NylaSchedulerAPIConnector {
+    private schedulerStore;
+    private schedulerAPIURL;
+    private sessionId;
+    constructor({ schedulerAPIURL, schedulerStore, sessionId }: NylasSchedulerAPIConnectorOptions);
+    makeAPIRequest<T>(path: string, method: string, body: string | undefined, headers?: {}): Promise<NylasResponse<T>>;
+    selectDate(date: Date): void;
+    selectTime(time: Timeslot): void;
+    selectTimezone(timezone: string): void;
+    toggleAdditionalData(value: boolean): void;
+    setParticipantName(name: string): void;
+    setParticipantEmail(email: string): void;
+    setReschedule(bookingID: string): Promise<void>;
+    bookTimeslot(data?: NylasSchedulerBookingData & {
+        timeslot?: Timeslot;
+    }): Promise<NylasResponse<NylasEvent>>;
+    getAvailability(startTime?: number, endTime?: number): Promise<NylasResponse<AvailabilityResponse>>;
+    cancelBooking(bookingId: string): Promise<NylasResponse<null>>;
+    rescheduleBooking(bookingId: string, data: NylasSchedulerBookingData): Promise<NylasResponse<NylasEvent>>;
+}
+export {};

package/dist/types/connector/shared/api/threads.d.ts

@@ -0,0 +1,20 @@
+import { NylasAuthType, Thread, ThreadQueryParameters } from '@nylas/core';
+import { NylasAuthStoreType, NylasMailboxStoreType } from '../../../components';
+import { RouterInterface } from "../../../routers/router-interface";
+export declare class NylasThreadsConnector {
+    private nylasAuth;
+    private nylasAuthStore;
+    private nylasMailboxStore;
+    private router;
+    constructor(nylasAuth: NylasAuthType, nylasAuthStore: NylasAuthStoreType, nylasMailboxStore: NylasMailboxStoreType, router: RouterInterface);
+    getThreads(overrideQueryParams?: Partial<ThreadQueryParameters>, updateMethod?: 'prepend' | 'append' | 'overwrite', updateState?: boolean): Promise<Thread[]>;
+    getThread(threadId: string): Promise<Thread>;
+    nextThreadPage(updateMethod?: 'prepend' | 'append' | 'overwrite', updateLoadingState?: boolean): Promise<Thread[]>;
+    previousThreadPage(aupdateMethod?: 'prepend' | 'append' | 'overwrite', updateLoadingState?: boolean): Promise<Thread[]>;
+    updateThreadQueryParams(params: Partial<ThreadQueryParameters>): void;
+    back(): void;
+    unSelectThread(): void;
+    selectThread(thread: Thread): Promise<void>;
+    markThreadAsRead(thread: Thread): Promise<Thread>;
+    updateThread(thread: Thread, updateThread: Partial<Thread>): Promise<Thread>;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './components';
+export { ObservableMap } from '@stencil/store';
+import NylasThemeStore, { NylasTheme } from './common/nylas-theme';
+export { NylasThemeStore, NylasTheme };

package/dist/types/routers/hash-router.d.ts

@@ -0,0 +1,21 @@
+import { RouteListener, RouteParams, RoutePath, RouterInterface } from './router-interface';
+export declare class PolyFillHashChangeEvent extends Event {
+    oldURL?: string;
+    newURL?: string;
+    constructor(type: string, eventInitDict: HashChangeEventInit);
+}
+export declare class HashRouter implements RouterInterface {
+    private routeChangeListeners;
+    constructor();
+    destroy(): void;
+    init(): void;
+    addRouteChangeListener<Path extends RoutePath>(route: Path, listener: RouteListener<Path>): void;
+    navigate(route: string, shallow: boolean): void;
+    setRoute(route: string): void;
+    matchRoute(route: string, path: string): boolean;
+    getRouteParams<Path extends RoutePath>(route: Path): RouteParams<Path>;
+    getRouteWithParams(route: string, routeParams: Record<string, any>): string;
+    getRoute(): string;
+    onRouteChange(event: HashChangeEvent): void;
+    getBasePath(): string;
+}

package/dist/types/routers/router-interface.d.ts

@@ -0,0 +1,16 @@
+export type RoutePath = string;
+export type RouteParams<Path extends string> = Path extends `${infer _Start}:${infer Param}/${infer Rest}` ? {
+    [key in Param | keyof RouteParams<Rest>]: string;
+} : Path extends `${infer _Start}:${infer Param}` ? {
+    [key in Param]: string;
+} : {};
+export type RouteListener<Path extends string> = (route: Path, path: string, routeParams: RouteParams<Path>) => Promise<void>;
+export interface RouterInterface {
+    init(): void;
+    addRouteChangeListener<Path extends RoutePath>(route: Path, listener: RouteListener<Path>): void;
+    setRoute(route: string): void;
+    navigate(route: string, shallow: boolean): void;
+    getRoute(): string;
+    getBasePath(): string;
+    matchRoute(route: string, path: string): boolean;
+}