@nylas/web-elements 1.0.0-prealpha1

package/dist/types/common/icons/play.d.ts

@@ -0,0 +1,5 @@
+export declare class PlayIcon {
+    width: string;
+    height: string;
+    render(): any;
+}

package/dist/types/common/icons/refresh.d.ts

@@ -0,0 +1,5 @@
+export declare class RefreshIcon {
+    width: string;
+    height: string;
+    render(): any;
+}

package/dist/types/common/icons/reply-all.d.ts

@@ -0,0 +1,5 @@
+export declare class ReplyAllIcon {
+    width: string;
+    height: string;
+    render(): any;
+}

package/dist/types/common/icons/reply.d.ts

@@ -0,0 +1,5 @@
+export declare class ReplyIcon {
+    width: string;
+    height: string;
+    render(): any;
+}

package/dist/types/common/icons/sent.d.ts

@@ -0,0 +1,5 @@
+export declare class SentIcon {
+    width: string;
+    height: string;
+    render(): any;
+}

package/dist/types/common/icons/spam.d.ts

@@ -0,0 +1,5 @@
+export declare class SpamIcon {
+    width: string;
+    height: string;
+    render(): any;
+}

package/dist/types/common/icons/star.d.ts

@@ -0,0 +1,5 @@
+export declare class StarIcon {
+    width: string;
+    height: string;
+    render(): any;
+}

package/dist/types/common/icons/stop.d.ts

@@ -0,0 +1,5 @@
+export declare class StopIcon {
+    width: string;
+    height: string;
+    render(): any;
+}

package/dist/types/common/icons/translate.d.ts

@@ -0,0 +1,5 @@
+export declare class GlobeIcon {
+    width: string;
+    height: string;
+    render(): any;
+}

package/dist/types/common/icons/trash.d.ts

@@ -0,0 +1,5 @@
+export declare class TrashIcon {
+    width: string;
+    height: string;
+    render(): any;
+}

package/dist/types/common/icons/underline.d.ts

@@ -0,0 +1,5 @@
+export declare class UnderlineIcon {
+    width: string;
+    height: string;
+    render(): any;
+}

package/dist/types/common/icons/warning.d.ts

@@ -0,0 +1,5 @@
+export declare class WarningIcon {
+    width: string;
+    height: string;
+    render(): any;
+}

package/dist/types/common/mocks/threads.d.ts

@@ -0,0 +1,3 @@
+import { Thread } from '@nylas/core';
+declare const mockThreads: Thread[];
+export default mockThreads;

package/dist/types/common/nylas-theme/index.d.ts

@@ -0,0 +1,27 @@
+export type NylasTheme = Partial<{
+    '--nylas-color-primary-50': string;
+    '--nylas-color-primary-100': string;
+    '--nylas-color-primary-200': string;
+    '--nylas-color-primary-300': string;
+    '--nylas-color-primary-400': string;
+    '--nylas-color-primary-500': string;
+    '--nylas-color-primary-600': string;
+    '--nylas-color-primary-700': string;
+    '--nylas-color-primary-800': string;
+    '--nylas-color-primary-900': string;
+    '--nylas-color-primary-950': string;
+}>;
+declare const store: import("@stencil/store").ObservableMap<Partial<{
+    '--nylas-color-primary-50': string;
+    '--nylas-color-primary-100': string;
+    '--nylas-color-primary-200': string;
+    '--nylas-color-primary-300': string;
+    '--nylas-color-primary-400': string;
+    '--nylas-color-primary-500': string;
+    '--nylas-color-primary-600': string;
+    '--nylas-color-primary-700': string;
+    '--nylas-color-primary-800': string;
+    '--nylas-color-primary-900': string;
+    '--nylas-color-primary-950': string;
+}>>;
+export default store;

package/dist/types/common/register-component.d.ts

@@ -0,0 +1,29 @@
+import { BaseNylasConnectorInterface } from "../connector/connector-interface";
+import { ComponentInterface } from '../stencil-public-runtime';
+import { CombinedStoreStateKeys, EventEmitterEventType, ExtractEventEmitterKeys, ExtractEventEmitterProperties } from './types';
+export interface RegisteredComponent<H extends ComponentInterface, B extends BaseNylasConnectorInterface, MailboxStores = string> {
+    name: string;
+    element: HTMLElement;
+    getStoresToProp?: keyof H;
+    storeToProps?: Map<string, keyof H>;
+    stateToProps?: Map<MailboxStores, keyof H>;
+    eventToProps?: Map<ExtractEventEmitterKeys<H>, (event: CustomEvent<EventEmitterEventType<H[ExtractEventEmitterKeys<H>]>>, nylasConnector: B) => Promise<void>>;
+    authToProp?: keyof H;
+    connectorToProp?: keyof H;
+    registrationEventName?: string;
+    unregistrationEventName?: string;
+}
+export declare function createComponentEvent<T extends ComponentInterface, B extends BaseNylasConnectorInterface>(instance: T, registeredComponent: RegisteredComponent<T, B>, eventName?: string): CustomEvent<RegisteredComponent<T, B, string>>;
+export declare function unregisterComponentEvent<T extends ComponentInterface, B extends BaseNylasConnectorInterface>(instance: T, registeredComponent: RegisteredComponent<T, B>, eventName?: string): CustomEvent<RegisteredComponent<T, B, string>>;
+export interface RegisterComponentConfig<H extends ComponentInterface, B extends BaseNylasConnectorInterface, MailboxStores> extends Omit<RegisteredComponent<H, B, MailboxStores>, 'eventToProps' | 'name' | 'element'> {
+    name: string;
+    eventToProps?: Partial<{
+        [P in ExtractEventEmitterProperties<H> as P['key']]: (event: CustomEvent<P['eventType']>, nylasConnector: B) => Promise<void>;
+    }>;
+    fireRegisterEvent?: boolean;
+}
+export interface NylasComponentInterface extends ComponentInterface {
+    authToProp?: keyof this;
+    connectorToProp?: keyof this;
+}
+export declare function RegisterComponent<H extends NylasComponentInterface, B extends BaseNylasConnectorInterface, MailboxStores extends Record<string, any>>(config: RegisterComponentConfig<H, B, CombinedStoreStateKeys<keyof MailboxStores, MailboxStores>>): (target: H, propKey: string) => void;

package/dist/types/common/types.d.ts

@@ -0,0 +1,108 @@
+import { Message } from '@nylas/core';
+import { EventEmitter } from '../stencil-public-runtime';
+export type DataState = 'loading' | 'ready';
+type StoresType = unknown;
+type StoreInstances = {
+    [K in keyof StoresType]: StoresType[K];
+};
+type StoreStateKeys<T> = T extends {
+    state: infer S;
+} ? keyof S : never;
+export type CombinedStoreStateKeys<SK extends keyof S, S = StoreInstances> = {
+    [StoreKey in SK]: StoreStateKeys<S[StoreKey]> extends never | undefined ? never : `${StoreKey & string}.${StoreStateKeys<S[StoreKey]> & string}`;
+}[SK];
+export type InternalMessage = {
+    id: string;
+    data: Message;
+    collapse: boolean;
+    showContactData: boolean;
+};
+export type InternalAttachment = {
+    blob: Blob;
+    filename: string;
+    contentType: string;
+    size: number;
+    messageId: string;
+};
+export type MethodKeys<T> = {
+    [K in keyof T]: T[K] extends Function ? K : never;
+}[keyof T];
+export type AvailabilityTimeslot = {
+    emails: string[];
+    start_time: number;
+    end_time: number;
+};
+export type AvailabilityResponse = {
+    time_slots: AvailabilityTimeslot[];
+    participants: {
+        email: string;
+        name: string;
+    }[];
+    duration: number;
+};
+export type ExtractEventEmitterKeys<T> = {
+    [K in keyof T]: T[K] extends EventEmitter<any> ? K : never;
+}[keyof T];
+export type EventEmitterEventType<T> = T extends EventEmitter<infer U> ? U : never;
+export type ExtractEventEmitterProperties<T> = {
+    [K in keyof T]: T[K] extends EventEmitter<infer U> ? {
+        key: K;
+        eventType: U;
+    } : never;
+}[keyof T];
+export type NylasEvent = {
+    id: string;
+    event_id: string;
+    owner_email: string;
+    status: string;
+    booking_data: {
+        participants: {
+            email: string;
+            name: string;
+        }[];
+        duration: number;
+        event_type: number;
+        start_time: number;
+        end_time: number;
+        title: string;
+        description: string;
+        timezone: string;
+    };
+    created_at: string;
+    updated_at: string;
+    config: {
+        id: number;
+        data: {
+            version: string;
+            availability: {
+                duration_minutes: number;
+                interval_minutes: number;
+                round_to_30_minutes: boolean;
+                participants: {
+                    email: string;
+                    name: string;
+                    calendar_ids: string[];
+                    open_hours: {
+                        days: number[];
+                        timezone: string;
+                        start: string;
+                        end: string;
+                    }[];
+                }[];
+            };
+            event_booking: {
+                title: string;
+                description: string;
+                type: number;
+                organizer: {
+                    email: string;
+                    calendar_id: string;
+                };
+            };
+        };
+        created_at: string;
+        updated_at: string;
+        is_session_defined: boolean;
+    };
+};
+export {};

package/dist/types/components/mailbox/nylas-composer/nylas-composer.d.ts

@@ -0,0 +1,22 @@
+import { Message } from '@nylas/core';
+import { EventEmitter } from '../../../stencil-public-runtime';
+export declare class NylasComposer {
+    readonly host: HTMLElement;
+    readonly message?: Message;
+    readonly viewEmailElement?: HTMLNylasViewEmailElement | null;
+    readonly close: EventEmitter<MouseEvent>;
+    readonly send: EventEmitter<{
+        message: Message;
+        replyBody: string;
+    }>;
+    private editorEl?;
+    private toolbarEl?;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    componentWillLoad(): void;
+    componentDidLoad(): Promise<void>;
+    watchBody(newMessage: Message): void;
+    private closeComposer;
+    private sendComposer;
+    render(): any;
+}

package/dist/types/components/mailbox/nylas-composer/test/nylas-composer.spec-disabled.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/components/mailbox/nylas-list-folders/nylas-list-folders.d.ts

@@ -0,0 +1,19 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+import { Folder } from '@nylas/core';
+export declare class NylasListFolders {
+    readonly folders?: Folder[];
+    readonly selectedFolder?: string;
+    readonly folderSelected: EventEmitter<Folder>;
+    defaultFolders?: Folder[];
+    otherFolders?: Folder[];
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    componentWillLoad(): Promise<void>;
+    componentDidLoad(): Promise<void>;
+    watchFolders(newFolders: Folder[]): void;
+    private folderSelectedHandler;
+    private formatFolderName;
+    private getFolderIcon;
+    render(): any;
+}

package/dist/types/components/mailbox/nylas-list-threads/nylas-list-threads.d.ts

@@ -0,0 +1,19 @@
+import { DataState } from "../../../common/types";
+import { Thread } from '@nylas/core';
+import { TokenInfo } from '@nylas/core/dist/auth';
+import { EventEmitter } from '../../../stencil-public-runtime';
+export declare class NylasListThreads {
+    readonly threads: Thread[];
+    readonly isAuthenticated: boolean;
+    readonly tokenInfo?: TokenInfo;
+    readonly state: DataState;
+    readonly showCheckbox: boolean;
+    readonly threadSelected: EventEmitter<Thread>;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    componentWillLoad(): Promise<void>;
+    componentDidLoad(): Promise<void>;
+    private handleThreadSelected;
+    private handleCheckboxClick;
+    render(): any;
+}

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

@@ -0,0 +1,35 @@
+import { RegisteredComponent } from "../../../common/register-component";
+import type { EventOverride } from "../../../common/component-types";
+import { NylasMailboxConnector } from "../../../connector/nylas-mailbox-connector/index";
+import { NylasAuthStoreState, NylasAuthStoreType } from "../../../stores/auth-store";
+import { NylasMailboxStoreState, NylasMailboxStoreType } from "../../../stores/mailbox-store";
+import { AuthConfg, NylasAuthType } from '@nylas/core';
+import { EventEmitter } from '../../../stencil-public-runtime';
+export declare class NylasMailbox {
+    private stores?;
+    private baseProvider?;
+    private nylasAuth?;
+    private router?;
+    private nylasMailboxConnector?;
+    private host;
+    readonly automaticComponentRegistration: boolean;
+    eventOverrides: EventOverride<Exclude<typeof this.nylasMailboxConnector, undefined>>;
+    readonly authConfig?: AuthConfg;
+    readonly defaultAuthStoreState?: NylasAuthStoreState;
+    readonly defaultMailboxStoreState?: NylasMailboxStoreState;
+    readonly init: EventEmitter<HTMLNylasMailboxElement>;
+    readonly loggedIn: EventEmitter<HTMLNylasMailboxElement>;
+    readonly loggedOut: EventEmitter<HTMLNylasMailboxElement>;
+    connectedCallback(): void;
+    componentWillLoad(): Promise<void>;
+    componentDidLoad(): Promise<void>;
+    componentDisconnected(): void;
+    registerComponentHandler(event: CustomEvent<RegisteredComponent<any, any>>): Promise<void>;
+    unregisterComponentHandler(event: CustomEvent<RegisteredComponent<any, any>>): Promise<void>;
+    getMailboxStore(): Promise<NylasMailboxStoreType | undefined>;
+    getAuthStore(): Promise<NylasAuthStoreType | undefined>;
+    getNylasAuth(): Promise<NylasAuthType | undefined>;
+    getNylasMailboxConnector(): Promise<NylasMailboxConnector | undefined>;
+    private handleAuthChange;
+    render(): any;
+}

package/dist/types/components/mailbox/nylas-mailbox-pagination/nylas-mailbox-pagination.d.ts

@@ -0,0 +1,30 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+export type PaginationEvent = {
+    hasChildren: boolean;
+};
+export declare class NylasMailboxPagination {
+    host: HTMLNylasMailboxPaginationElement;
+    state: 'ready' | 'loading' | 'error';
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    scrollTarget: 'container' | 'page';
+    mobileOnlyInfiniteScroll: boolean;
+    mobileViewPortWidth: number;
+    next: EventEmitter<PaginationEvent>;
+    previous: EventEmitter<PaginationEvent>;
+    private containerElement?;
+    constructor();
+    connectedCallback(): void;
+    componentWillLoad(): Promise<void>;
+    componentDidLoad(): Promise<void>;
+    componentWillRender(): Promise<void>;
+    disconnectedCallback(): void;
+    handlePageScroll(_event: Event): void;
+    nextPage(): Promise<void>;
+    previousPage(): Promise<void>;
+    private handleContainerScroll;
+    private isScrollAtContainerBottom;
+    private isScrollAtPageBottom;
+    private get canScroll();
+    render(): any;
+}

package/dist/types/components/mailbox/nylas-mailbox-toolbar-button/nylas-mailbox-toolbar-button.d.ts

@@ -0,0 +1,26 @@
+import { MethodKeys } from "../../../common/types";
+import { NylasMailboxConnectorInterface } from "../../../connector/connector-interface";
+import { ObservableMap } from '@stencil/store';
+export type Stores = Record<string, ObservableMap<any>>;
+export type PublicMethodsOfNylasMailboxConnector = Pick<NylasMailboxConnectorInterface, MethodKeys<NylasMailboxConnectorInterface>>;
+export type PropertyPaths<T> = T extends object ? {
+    [K in keyof T]: T[K] extends Function ? `${K & string}` : `${K & string}.${PropertyPaths<T[K]>}`;
+}[keyof T] : '';
+export type MethodsOfNylasMailboxConnector = PropertyPaths<NylasMailboxConnectorInterface>;
+export declare class NylasMailboxToolbarButton {
+    private host;
+    readonly method: MethodsOfNylasMailboxConnector;
+    readonly dataState?: string;
+    readonly iconOnly: boolean;
+    readonly mailboxConnector?: NylasMailboxConnectorInterface;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    componentWillLoad(): Promise<void>;
+    componentDidLoad(): Promise<void>;
+    private onClick;
+    private callMethod;
+    private renderByState;
+    private hasSlot;
+    render(): any;
+}

package/dist/types/components/mailbox/nylas-summarize-message-button/nylas-summarize-message-button.d.ts

@@ -0,0 +1,25 @@
+import { Message } from '@nylas/core';
+import { EventEmitter } from '../../../stencil-public-runtime';
+export type SummarizeEvent = {
+    playAudio: (ttsResponseBody: Promise<ReadableStream<Uint8Array> | null>) => Promise<void>;
+    updateState: (state: 'loading' | 'playing' | 'stopped') => Promise<void>;
+    abortController: AbortController;
+    message: Message;
+};
+export declare class NylasSummarizeMessageButton {
+    readonly message?: Message;
+    readonly summarize: EventEmitter<SummarizeEvent>;
+    state: 'loading' | 'playing' | 'stopped';
+    private audioRef?;
+    private abortController;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    componentWillLoad(): Promise<void>;
+    componentDidLoad(): Promise<void>;
+    private onClick;
+    updateState(state: 'loading' | 'playing' | 'stopped'): Promise<void>;
+    playAudio(ttsResponseBody: Promise<ReadableStream<Uint8Array> | null>): Promise<void>;
+    private readChunk;
+    render(): any;
+}

package/dist/types/components/mailbox/nylas-threads-refresh/nylas-threads-refresh.d.ts

@@ -0,0 +1,23 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+export type RefreshEvent = {
+    updateState: (state: 'ready' | 'loading' | 'error') => Promise<void>;
+};
+export declare class NylasThreadsRefresh {
+    private readonly threshold;
+    start: number;
+    state: 'ready' | 'loading' | 'error';
+    pulling: boolean;
+    refresh: EventEmitter<RefreshEvent>;
+    private containerElement?;
+    private contentElement?;
+    constructor();
+    connectedCallback(): void;
+    componentWillLoad(): Promise<void>;
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    updateState(state: 'ready' | 'loading' | 'error'): Promise<void>;
+    private onTouchStart;
+    private onTouchMove;
+    private onTouchEnd;
+    render(): any;
+}

package/dist/types/components/mailbox/nylas-threads-search/nylas-threads-search.d.ts

@@ -0,0 +1,13 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+export declare class NylasThreadsSearch {
+    readonly query: string;
+    readonly search: EventEmitter<string>;
+    internalQuery: string;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    componentWillLoad(): Promise<void>;
+    componentDidLoad(): Promise<void>;
+    onQueryChange(): void;
+    private onSearch;
+    render(): any;
+}

package/dist/types/components/mailbox/nylas-view-email/nylas-view-email.d.ts

@@ -0,0 +1,25 @@
+import { InternalAttachment } from "../../../common/types";
+import { Message } from '@nylas/core';
+export declare class NylasViewEmail {
+    readonly host: HTMLDivElement;
+    readonly message?: Message;
+    readonly parent?: HTMLElement;
+    readonly attachments: InternalAttachment[];
+    readonly detectDarkMode: boolean;
+    state: 'loading' | 'ready';
+    sanitizedBody: string;
+    styles: HTMLStyleElement[];
+    private viewEmailElement?;
+    private hoistedFontURLs;
+    private readonly htmlElement;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    componentWillLoad(): Promise<void>;
+    componentDidLoad(): Promise<void>;
+    messageChanged(): Promise<void>;
+    private setBody;
+    handleScroll(): void;
+    viewEmailElementChanged(): void;
+    private handleMobileSize;
+    render(): any;
+}

package/dist/types/components/mailbox/nylas-view-thread/nylas-view-thread.d.ts

@@ -0,0 +1,30 @@
+import { DataState, InternalAttachment, InternalMessage } from "../../../common/types";
+import { Message, Thread } from '@nylas/core';
+import { EventEmitter } from '../../../stencil-public-runtime';
+export declare class NylasViewThread {
+    readonly host: HTMLDivElement;
+    readonly draft?: Message;
+    readonly thread?: Thread;
+    readonly messages: Message[];
+    readonly attachments: InternalAttachment[];
+    readonly threadSelected: EventEmitter<Thread>;
+    showContactDataClicked: EventEmitter<Message>;
+    messageClicked: EventEmitter<Message>;
+    readonly state: DataState;
+    internalMessages: InternalMessage[];
+    showAllEmails: boolean;
+    showComposer: boolean;
+    private nylasViewEmailElement;
+    private nylasComposerElement;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    componentWillLoad(): Promise<void>;
+    componentDidLoad(): Promise<void>;
+    threadChanged(thread: Thread | undefined): Promise<void>;
+    updateInternalMessages(messages: Message[]): void;
+    private onShowContactDataClick;
+    private onMessageClick;
+    private onShowAllEmailsClick;
+    private showComposerClick;
+    render(): any;
+}

package/dist/types/components/mailbox/nylas-view-thread/view-thread-message.d.ts

@@ -0,0 +1,12 @@
+import { InternalAttachment, InternalMessage } from "../../../common/types";
+import { FunctionalComponent } from '../../../stencil-public-runtime';
+export type ViewThreadMessageProps = {
+    message: InternalMessage;
+    attachments: InternalAttachment[];
+    viewEmailElement?: HTMLNylasViewEmailElement | null;
+    composerElement?: HTMLNylasComposerElement | null;
+    onShowContactDataClick: (event: MouseEvent) => void;
+    onMessageClick: (event: MouseEvent) => void;
+    parent?: HTMLElement;
+};
+export declare const ViewThreadMessage: FunctionalComponent<ViewThreadMessageProps>;

package/dist/types/components/nylas-if-state/nylas-if-state.d.ts

@@ -0,0 +1,22 @@
+import { ObservableMap } from '@stencil/store';
+export type Stores = Record<string, ObservableMap<any>>;
+export type Transitions = 'none' | 'fade' | 'slide' | 'swipe';
+export declare class NylasIfState {
+    readonly state?: string;
+    readonly isStateSet?: boolean;
+    readonly isBoolean?: boolean;
+    readonly getStore?: <K extends keyof Stores>(name: K) => Stores[K];
+    readonly transition: Transitions;
+    show: boolean;
+    classes: Record<string, boolean>;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    componentWillLoad(): Promise<void>;
+    componentDidLoad(): Promise<void>;
+    private shouldRender;
+    onGetStoreChange(): void;
+    private watchStore;
+    private initTransition;
+    render(): any;
+}

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

@@ -0,0 +1,26 @@
+import { NylasAuthConnectorInterface } from "../../connector/connector-interface";
+import { EventEmitter } from '../../stencil-public-runtime';
+export declare class NylasLogin {
+    readonly isAuthenticated: boolean;
+    readonly nylasConnector?: NylasAuthConnectorInterface;
+    readonly scopes?: string[];
+    readonly loginMethod: 'redirect' | 'emebded';
+    readonly companyName: string;
+    readonly logoUrl: string;
+    readonly logoWidth?: string;
+    readonly providers?: string;
+    readonly buttonText: string;
+    buttonClick: EventEmitter<{
+        url?: string;
+    }>;
+    email: string;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    componentWillLoad(): void;
+    componentDidLoad(): Promise<void>;
+    private _handleLoginRedirect;
+    private _onGoogleButtonClick;
+    private _onMicrosoftButtonClick;
+    private _onFormSubmit;
+    render(): any;
+}

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

@@ -0,0 +1,35 @@
+import { RegisteredComponent } from "../../common/register-component";
+import { NylasConnector } from "../../connector/nylas-connector/index";
+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 { AuthConfg } from '@nylas/core';
+import { EventEmitter } from '../../stencil-public-runtime';
+import type { EventOverride } from "../../common/component-types";
+export declare class NylasProvider {
+    private stores?;
+    private baseProvider?;
+    private nylasAuth?;
+    private nylasConnector?;
+    private host;
+    readonly authConfig?: AuthConfg;
+    eventOverrides: EventOverride<Exclude<typeof this.nylasConnector, undefined>>;
+    automaticComponentRegistration: boolean;
+    init: EventEmitter<HTMLNylasProviderElement>;
+    loggedIn: EventEmitter<HTMLNylasProviderElement>;
+    loggedOut: EventEmitter<HTMLNylasProviderElement>;
+    connectedCallback(): void;
+    componentWillLoad(): Promise<void>;
+    componentDidLoad(): void;
+    componentDisconnected(): void;
+    registerComponentHandler(event: CustomEvent<RegisteredComponent<any, any>>): Promise<void>;
+    unregisterComponentHandler(event: CustomEvent<RegisteredComponent<any, any>>): Promise<void>;
+    private handleAuthChange;
+    getNylasAuth(): Promise<NylasAuthType | undefined>;
+    getNylasConnector(): Promise<NylasConnector | undefined>;
+    getMailboxStore(): Promise<NylasMailboxStoreType | undefined>;
+    getAuthStore(): Promise<NylasAuthStoreType | undefined>;
+    getNylasSchedulerStore(): Promise<NylasSchedulerStoreType | undefined>;
+    render(): any;
+}