@sneat/extensions-schedulus-shared 0.3.0

package/lib/components/calendar-filter.service.d.ts

@@ -0,0 +1,8 @@
+import { ICalendarFilter } from './calendar/components/calendar-filter/calendar-filter';
+export declare const emptyCalendarFilter: ICalendarFilter;
+export declare class CalendarFilterService {
+    private readonly filter$;
+    readonly filter: import("rxjs").Observable<ICalendarFilter>;
+    next(filter: ICalendarFilter): void;
+    resetScheduleFilter(event: Event): void;
+}

package/lib/components/calendar-slots.d.ts

@@ -0,0 +1,5 @@
+import { IRelatedModules } from '@sneat/dto';
+import { ISlotUIContext } from '@sneat/mod-schedulus-core';
+import { ICalendarFilter } from './calendar/components/calendar-filter/calendar-filter';
+export declare function hasContact(spaceID: string, contactIDs: readonly string[], related?: IRelatedModules): boolean;
+export declare function isSlotVisible(slot: ISlotUIContext, filter: ICalendarFilter): boolean;

package/lib/components/happening-base.component.d.ts

@@ -0,0 +1,46 @@
+import { ChangeDetectorRef, EventEmitter } from '@angular/core';
+import { ModalController } from '@ionic/angular/standalone';
+import { IContactusSpaceDboAndID } from '@sneat/contactus-core';
+import { ContactsSelectorService } from '@sneat/contactus-shared';
+import { IHappeningContext, WeekdayCode2 } from '@sneat/mod-schedulus-core';
+import { IErrorLogger } from '@sneat/core';
+import { WithSpaceInput } from '@sneat/space-services';
+import { ISpaceContext } from '@sneat/space-models';
+import { SpaceNavService } from '@sneat/space-services';
+import { HappeningService } from '../services/happening.service';
+import * as i0 from "@angular/core";
+export declare class HappeningBaseComponentParams {
+    readonly errorLogger: IErrorLogger;
+    readonly happeningService: HappeningService;
+    readonly spaceNavService: SpaceNavService;
+    readonly contactsSelectorService: ContactsSelectorService;
+    readonly modalController: ModalController;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HappeningBaseComponentParams, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HappeningBaseComponentParams>;
+}
+export declare abstract class HappeningBaseComponent extends WithSpaceInput {
+    static providers: (typeof HappeningBaseComponentParams)[];
+    static metadata: {
+        inputs: string[];
+        outputs: string[];
+    };
+    readonly $happening: import("@angular/core").InputSignal<IHappeningContext>;
+    readonly $contactusSpace: import("@angular/core").InputSignal<IContactusSpaceDboAndID | undefined>;
+    readonly deleted: EventEmitter<string>;
+    get date(): Date | undefined;
+    get wd(): WeekdayCode2 | undefined;
+    deleting: boolean;
+    get happeningService(): HappeningService;
+    get contactsSelectorService(): ContactsSelectorService;
+    private readonly happeningBaseComponentParams;
+    protected readonly changeDetectorRef: ChangeDetectorRef;
+    protected constructor();
+    protected goHappening(event: Event): void;
+    protected delete(event: Event): void;
+    protected selectMembers(event: Event): void;
+    private readonly onContactAdded;
+    protected spaceAndHappening(): [ISpaceContext, IHappeningContext];
+    private readonly onMemberRemoved;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HappeningBaseComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HappeningBaseComponent, never, never, { "$happening": { "alias": "$happening"; "required": true; "isSignal": true; }; "$contactusSpace": { "alias": "$contactusSpace"; "required": true; "isSignal": true; }; }, { "deleted": "deleted"; }, never, never, true, never>;
+}

package/lib/components/happening-card/happening-card.component.d.ts

@@ -0,0 +1,11 @@
+import { IContactWithBrief } from '@sneat/contactus-core';
+import { HappeningBaseComponent } from '../happening-base.component';
+import * as i0 from "@angular/core";
+export declare class HappeningCardComponent extends HappeningBaseComponent {
+    protected readonly $relatedContactIDs: import("@angular/core").Signal<readonly string[]>;
+    protected readonly $hasRelatedContacts: import("@angular/core").Signal<boolean>;
+    constructor();
+    protected removeContact(contact: IContactWithBrief): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HappeningCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HappeningCardComponent, "sneat-happening-card", never, {}, {}, never, never, true, never>;
+}

package/lib/components/happening-component-base-params.d.ts

@@ -0,0 +1,16 @@
+import { CalendariumSpaceService } from '../services/calendarium-space.service';
+import { SpaceComponentBaseParams } from '@sneat/space-components';
+import { HappeningService } from '../services/happening.service';
+import * as i0 from "@angular/core";
+export declare class HappeningComponentBaseParams {
+    readonly spaceParams: SpaceComponentBaseParams;
+    readonly happeningService: HappeningService;
+    readonly calendariumSpaceService: CalendariumSpaceService;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HappeningComponentBaseParams, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HappeningComponentBaseParams>;
+}
+export declare class HappeningComponentBaseParamsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HappeningComponentBaseParamsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HappeningComponentBaseParamsModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HappeningComponentBaseParamsModule>;
+}

package/lib/components/happening-form/happening-form.component.d.ts

@@ -0,0 +1,52 @@
+import { AfterViewInit, EventEmitter } from '@angular/core';
+import { FormControl, FormGroup } from '@angular/forms';
+import { IonInput } from '@ionic/angular/standalone';
+import { HappeningType, IHappeningContext, IHappeningSlotWithID, WeekdayCode2 } from '@sneat/mod-schedulus-core';
+import { HappeningSlotsComponent } from '../happening-slots/happening-slots.component';
+import { WithSpaceInput } from '@sneat/space-services';
+import * as i0 from "@angular/core";
+export declare class HappeningFormComponent extends WithSpaceInput implements AfterViewInit {
+    private readonly changeDetectorRef;
+    private readonly happeningService;
+    private readonly params;
+    readonly $happening: import("@angular/core").InputSignal<IHappeningContext>;
+    protected readonly $happeningID: import("@angular/core").Signal<string>;
+    protected readonly $mode: import("@angular/core").Signal<"edit" | "create">;
+    protected readonly $hasDescription: import("@angular/core").Signal<string | undefined>;
+    wd?: WeekdayCode2;
+    date?: string;
+    readonly happeningChange: EventEmitter<IHappeningContext>;
+    private readonly navController;
+    titleInput?: IonInput;
+    happeningSlotsComponent?: HappeningSlotsComponent;
+    protected readonly $isCreating: import("@angular/core").WritableSignal<boolean>;
+    protected readonly $isCancelling: import("@angular/core").WritableSignal<boolean>;
+    protected readonly $isDeleting: import("@angular/core").WritableSignal<boolean>;
+    protected readonly $slots: import("@angular/core").Signal<IHappeningSlotWithID[] | undefined>;
+    protected readonly happeningTitle: FormControl<string | null>;
+    private readonly modalController;
+    protected editTitle(event: Event): Promise<void>;
+    protected readonly happeningType: FormControl<HappeningType | null>;
+    protected readonly happeningForm: FormGroup<{
+        title: FormControl<string | null>;
+    }>;
+    private readonly hasNavHistory;
+    protected isToDo: boolean;
+    private readonly onHappeningTitleChanged;
+    constructor();
+    ngAfterViewInit(): void;
+    protected onHappeningTypeChanged(event: Event): void;
+    protected onTitleEnter(_event?: Event): void;
+    protected onTitleChanged(event: CustomEvent): void;
+    ionViewDidEnter(): void;
+    protected onSlotAdded(_slot?: unknown): void;
+    protected onHappeningChanged(happening: IHappeningContext): void;
+    protected formIsValid(): boolean;
+    private makeHappeningDto;
+    protected submit(): void;
+    private createHappening;
+    protected cancel(): void;
+    protected delete(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HappeningFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HappeningFormComponent, "sneat-happening-form", never, { "$happening": { "alias": "$happening"; "required": true; "isSignal": true; }; "wd": { "alias": "wd"; "required": false; }; "date": { "alias": "date"; "required": false; }; }, { "happeningChange": "happeningChange"; }, never, never, true, never>;
+}

package/lib/components/happening-form/happening-price-form/happening-price-modal.component.d.ts

@@ -0,0 +1,29 @@
+import { ChangeDetectorRef, EventEmitter } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { IHappeningContext, TermUnit } from '@sneat/mod-schedulus-core';
+import { SneatBaseModalComponent } from '@sneat/ui';
+import { HappeningService } from '../../../services/happening.service';
+import { SelectOption } from '@sneat/wizard';
+import * as i0 from "@angular/core";
+export declare class HappeningPriceModalComponent extends SneatBaseModalComponent {
+    protected readonly changeDetectorRef: ChangeDetectorRef;
+    protected readonly happeningService: HappeningService;
+    happening?: IHappeningContext;
+    happeningChange: EventEmitter<IHappeningContext>;
+    readonly canceled: EventEmitter<void>;
+    protected isSubmitting: boolean;
+    constructor();
+    protected readonly priceValue: FormControl<number | null | undefined>;
+    protected readonly priceCurrency: FormControl<string | null | undefined>;
+    protected readonly termLength: FormControl<number | null | undefined>;
+    protected termUnit?: TermUnit;
+    protected termPeriods: SelectOption[];
+    protected onTermLengthChange(): void;
+    private forceSelectOptionsRefresh;
+    private setTermLengths;
+    protected addPrice(event: Event): void;
+    private addPriceToNewHappening;
+    private submitPrice;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HappeningPriceModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HappeningPriceModalComponent, "sneat-happening-price-form", never, { "happening": { "alias": "happening"; "required": true; }; }, { "happeningChange": "happeningChange"; "canceled": "canceled"; }, never, never, true, never>;
+}

package/lib/components/happening-form/happening-prices/happening-prices.component.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter } from '@angular/core';
+import { IHappeningContext, IHappeningPrice } from '@sneat/mod-schedulus-core';
+import * as i0 from "@angular/core";
+export declare class HappeningPricesComponent {
+    private readonly errorLogger;
+    private readonly modalCtrl;
+    private readonly happeningService;
+    happening?: IHappeningContext;
+    readonly happeningChange: EventEmitter<IHappeningContext>;
+    protected openNewPriceForm(): void;
+    protected deletePrice(price: IHappeningPrice): void;
+    protected updatingPriceIDs: import("@angular/core").WritableSignal<readonly string[]>;
+    protected priceChecked(price: IHappeningPrice, event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HappeningPricesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HappeningPricesComponent, "sneat-happening-pricing", never, { "happening": { "alias": "happening"; "required": true; }; }, { "happeningChange": "happeningChange"; }, never, never, true, never>;
+}

package/lib/components/happening-participants/happening-participants.component.d.ts

@@ -0,0 +1,24 @@
+import { EventEmitter } from '@angular/core';
+import { ICheckChangedArgs } from '@sneat/contactus-shared';
+import { IHappeningContext } from '@sneat/mod-schedulus-core';
+import { WithSpaceInput } from '@sneat/space-services';
+import * as i0 from "@angular/core";
+export declare class HappeningParticipantsComponent extends WithSpaceInput {
+    private readonly happeningService;
+    readonly $happening: import("@angular/core").InputSignal<IHappeningContext>;
+    private readonly userService;
+    protected readonly $membersTabLabel: import("@angular/core").Signal<string>;
+    protected readonly $showMembersList: import("@angular/core").Signal<boolean>;
+    readonly happeningChange: EventEmitter<IHappeningContext>;
+    protected readonly $relatedContactIDs: import("@angular/core").Signal<readonly string[]>;
+    private readonly contactSelectorService;
+    private readonly analytics;
+    constructor();
+    protected onCheckChanged(args: ICheckChangedArgs): void;
+    private readonly emitHappeningChange;
+    private addRemoveRelated;
+    protected $isAddingContact: import("@angular/core").WritableSignal<boolean>;
+    protected addContact(event: Event, source: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HappeningParticipantsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HappeningParticipantsComponent, "sneat-happening-participants", never, { "$happening": { "alias": "$happening"; "required": true; "isSignal": true; }; }, { "happeningChange": "happeningChange"; }, never, never, true, never>;
+}

package/lib/components/happening-slot-form/happening-slot-form.component.d.ts

@@ -0,0 +1,76 @@
+import { EventEmitter, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+import { FormControl, UntypedFormGroup } from '@angular/forms';
+import { ModalController } from '@ionic/angular/standalone';
+import { ISelectItem } from '@sneat/ui';
+import { IHappeningSlot, ITiming, MonthlyMode, WeekdayCode2, IHappeningContext, Month, IHappeningSlotWithID } from '@sneat/mod-schedulus-core';
+import { StartEndDatetimeFormComponent } from '../start-end-datetime-form/start-end-datetime-form.component';
+import { WeekdaysFormBase } from '../weekdays/weekdays-form-base';
+import * as i0 from "@angular/core";
+type Happens = 'once' | 'weekly' | 'monthly' | 'yearly' | 'fortnightly';
+type Repeats = Exclude<Happens, 'once'>;
+export type HappeningSlotFormMode = 'modal' | 'in-form';
+export interface IHappeningSlotFormComponentInputs {
+    mode?: HappeningSlotFormMode;
+    happening?: IHappeningContext;
+    slotID?: string;
+    slot?: IHappeningSlot;
+    wd?: WeekdayCode2;
+    date?: string;
+    isToDo?: boolean;
+}
+export declare class HappeningSlotFormComponent extends WeekdaysFormBase implements OnChanges, OnDestroy, IHappeningSlotFormComponentInputs {
+    protected readonly modalCtrl: ModalController;
+    private readonly happeningService;
+    readonly $happening: import("@angular/core").InputSignal<IHappeningContext>;
+    readonly $happeningID: import("@angular/core").Signal<string>;
+    protected readonly $happeningType: import("@angular/core").Signal<import("@sneat/mod-schedulus-core").HappeningType | undefined>;
+    mode?: HappeningSlotFormMode;
+    slot?: IHappeningSlotWithID;
+    wd?: WeekdayCode2;
+    date?: string;
+    isToDo: boolean;
+    readonly slotAdded: EventEmitter<IHappeningSlot>;
+    readonly happeningChange: EventEmitter<IHappeningContext>;
+    readonly eventTimesChanged: EventEmitter<ITiming>;
+    startEndDatetimeForm?: StartEndDatetimeFormComponent;
+    protected timing: ITiming;
+    protected readonly error: import("@angular/core").WritableSignal<string>;
+    protected tab: 'when' | 'where';
+    protected readonly repeatsOptions: readonly ISelectItem[];
+    protected readonly monthlyMode: import("@angular/core").WritableSignal<"" | MonthlyMode>;
+    protected readonly monthlyDate: import("@angular/core").WritableSignal<number>;
+    protected onMonthlyModeChanged(s: string): void;
+    protected numberOfDaysInMonth: number;
+    protected readonly isUpdating: import("@angular/core").WritableSignal<boolean>;
+    protected readonly monthlyModes: readonly ISelectItem[];
+    protected readonly slotForm: UntypedFormGroup;
+    protected readonly repeats: import("@angular/core").WritableSignal<Repeats | undefined>;
+    protected readonly showWeekdays: import("@angular/core").Signal<boolean>;
+    protected readonly showTimeForm: import("@angular/core").Signal<boolean>;
+    protected readonly showAddSlotButton: import("@angular/core").Signal<boolean>;
+    constructor();
+    protected onRepeatsChanged(value: string): void;
+    private addOnceSlot;
+    private addWeeklySlot;
+    private initiateSlot;
+    protected readonly yearlyMonth: FormControl<Month | null | undefined>;
+    protected readonly monthDays: readonly number[][];
+    protected readonly months: string[];
+    protected setYearlyMonth(month: string): void;
+    protected setMonthlyDay(day: number): void;
+    protected addDaySlot(): IHappeningSlot | undefined;
+    private addSlotToHappening;
+    private addYearlySlot;
+    private addMonthlySlot;
+    protected saveChanges(): void;
+    protected applyChanges(): void;
+    protected addSlot(_timing?: ITiming): void;
+    private generateSlotID;
+    private getSlot;
+    onEventTimesChanged(): void;
+    protected onTimingChanged(timing: ITiming): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HappeningSlotFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HappeningSlotFormComponent, "sneat-happening-slot-form", never, { "$happening": { "alias": "$happening"; "required": true; "isSignal": true; }; "mode": { "alias": "mode"; "required": true; }; "slot": { "alias": "slot"; "required": false; }; "wd": { "alias": "wd"; "required": false; }; "date": { "alias": "date"; "required": false; }; "isToDo": { "alias": "isToDo"; "required": false; }; }, { "slotAdded": "slotAdded"; "happeningChange": "happeningChange"; "eventTimesChanged": "eventTimesChanged"; }, never, never, true, never>;
+}
+export {};

package/lib/components/happening-slot-form/happening-slot-modal.component.d.ts

@@ -0,0 +1,26 @@
+import { EventEmitter, OnChanges, OnDestroy, SimpleChanges, OnInit } from '@angular/core';
+import { IHappeningAdjustment, ITiming, IHappeningContext, IHappeningSlotWithID } from '@sneat/mod-schedulus-core';
+import { ISpaceContext } from '@sneat/space-models';
+import { IHappeningSlotFormComponentInputs } from './happening-slot-form.component';
+import * as i0 from "@angular/core";
+export declare class HappeningSlotModalComponent implements OnChanges, OnDestroy, IHappeningSlotFormComponentInputs, OnInit {
+    private readonly errorLogger;
+    private readonly modalController;
+    private readonly destroyed;
+    space?: ISpaceContext;
+    happening: IHappeningContext;
+    slot: IHappeningSlotWithID;
+    adjustment?: IHappeningAdjustment;
+    dateID?: string;
+    readonly happeningSlotChange: EventEmitter<IHappeningSlotWithID>;
+    onTimingChanged(timing: ITiming): void;
+    protected onHappeningChanged(happening: IHappeningContext): void;
+    private emitHappeningSlotChange;
+    close(event: Event): Promise<void>;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private processHappening;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HappeningSlotModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HappeningSlotModalComponent, "sneat-slot-modal", never, { "space": { "alias": "space"; "required": true; }; "happening": { "alias": "happening"; "required": true; }; "slot": { "alias": "slot"; "required": false; }; "adjustment": { "alias": "adjustment"; "required": false; }; "dateID": { "alias": "dateID"; "required": false; }; }, { "happeningSlotChange": "happeningSlotChange"; }, never, never, true, never>;
+}

package/lib/components/happening-slot-form/happening-slot-modal.service.d.ts

@@ -0,0 +1,18 @@
+import { IHappeningContext, ISlotAdjustment, IHappeningSlotWithID } from '@sneat/mod-schedulus-core';
+import * as i0 from "@angular/core";
+export interface EditRecurringSlotParams {
+    dateID: string;
+    editMode: 'series' | 'single';
+    adjustment?: ISlotAdjustment;
+}
+export declare class HappeningSlotModalService {
+    private readonly modalController;
+    editSingleHappeningSlot(event: Event, happening: IHappeningContext, recurring?: EditRecurringSlotParams, slot?: IHappeningSlotWithID): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HappeningSlotModalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HappeningSlotModalService>;
+}
+export declare class HappeningSlotModalServiceModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HappeningSlotModalServiceModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HappeningSlotModalServiceModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HappeningSlotModalServiceModule>;
+}

package/lib/components/happening-slot-participants/happening-slot-participants.component.d.ts

@@ -0,0 +1,19 @@
+import { IContactWithBrief, IContactWithBriefAndSpace } from '@sneat/contactus-core';
+import { ISlotUIContext } from '@sneat/mod-schedulus-core';
+import { SneatBaseComponent } from '@sneat/ui';
+import * as i0 from "@angular/core";
+export declare class HappeningSlotParticipantsComponent extends SneatBaseComponent {
+    private readonly changedDetectorRef;
+    private readonly contactusService;
+    protected contacts?: readonly IContactWithBriefAndSpace[];
+    protected readonly $spaceContacts: import("@angular/core").WritableSignal<readonly IContactWithBrief[] | undefined>;
+    readonly $happeningSlot: import("@angular/core").InputSignal<ISlotUIContext>;
+    protected readonly $relatedItems: import("@angular/core").Signal<Readonly<Record<string, import("@sneat/dto").IRelatedItem>>>;
+    protected $contacts: import("@angular/core").Signal<IContactWithBriefAndSpace[] | undefined>;
+    private readonly $spaceID;
+    constructor();
+    protected isUniqueFirstName(contact: IContactWithBriefAndSpace): boolean;
+    private onSpaceIDChanged;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HappeningSlotParticipantsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HappeningSlotParticipantsComponent, "sneat-happening-slot-participants", never, { "$happeningSlot": { "alias": "$happeningSlot"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/components/happening-slots/happening-slots.component.d.ts

@@ -0,0 +1,28 @@
+import { EventEmitter } from '@angular/core';
+import { IHappeningSlot, WeekdayCode2, IHappeningContext, IHappeningSlotWithID } from '@sneat/mod-schedulus-core';
+import * as i0 from "@angular/core";
+export interface AddSlotParams {
+    wd?: WeekdayCode2;
+}
+export declare class HappeningSlotsComponent {
+    private readonly errorLogger;
+    private readonly happeningService;
+    private readonly happeningSlotModalService;
+    readonly happening: import("@angular/core").InputSignal<IHappeningContext>;
+    readonly wd: import("@angular/core").InputSignal<WeekdayCode2 | undefined>;
+    readonly slotSelected: EventEmitter<IHappeningSlot>;
+    readonly happeningChange: EventEmitter<IHappeningContext>;
+    protected readonly $slots: import("@angular/core").Signal<IHappeningSlotWithID[] | undefined>;
+    protected readonly hasAnyWd: (slot: IHappeningSlotWithID, ...wds: readonly WeekdayCode2[]) => boolean;
+    protected removeSlot(event: Event, slot: IHappeningSlotWithID): void;
+    private removeSlotFromHappening;
+    private deleteSlot;
+    protected readonly $deletingSlotIDs: import("@angular/core").WritableSignal<readonly string[]>;
+    protected selectSlot(event: Event, slot: IHappeningSlotWithID): void;
+    protected onHappeningChanged(happening: IHappeningContext): void;
+    protected editingSlot?: IHappeningSlot;
+    protected showEditSlot(event: Event, slot: IHappeningSlotWithID): void;
+    protected showAddSlot(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HappeningSlotsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HappeningSlotsComponent, "sneat-happening-slots", never, { "happening": { "alias": "happening"; "required": true; "isSignal": true; }; "wd": { "alias": "wd"; "required": false; "isSignal": true; }; }, { "slotSelected": "slotSelected"; "happeningChange": "happeningChange"; }, never, never, true, never>;
+}

package/lib/components/index.d.ts

@@ -0,0 +1,5 @@
+export * from './calendar/calendar-brief.component';
+export * from './calendar/calendar-component-types';
+export * from './calendar/calendar.component';
+export * from './happening-form/happening-form.component';
+export * from './happening-component-base-params';

package/lib/components/start-end-dates-range-form/start-end-dates-range-form.component.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { ITiming } from '@sneat/mod-schedulus-core';
+import * as i0 from "@angular/core";
+export declare class StartEndDatesRangeFormComponent implements OnChanges {
+    timing?: ITiming;
+    timingChange: EventEmitter<ITiming>;
+    protected startEnabled: import("@angular/core").WritableSignal<boolean>;
+    protected endEnabled: import("@angular/core").WritableSignal<boolean>;
+    protected onStartChecked(event: Event): void;
+    protected onEndChecked(event: Event): void;
+    protected onStartChanged(event: Event): void;
+    protected onEndChanged(event: Event): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StartEndDatesRangeFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StartEndDatesRangeFormComponent, "sneat-start-end-dates-range-form", never, { "timing": { "alias": "timing"; "required": true; }; }, { "timingChange": "timingChange"; }, never, never, true, never>;
+}

package/lib/components/start-end-datetime-form/start-end-datetime-form.component.d.ts

@@ -0,0 +1,53 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { FormControl, UntypedFormGroup } from '@angular/forms';
+import { IonInput } from '@ionic/angular/standalone';
+import { HappeningType, ITiming } from '@sneat/mod-schedulus-core';
+import { isTomorrow } from '../calendar-core';
+import * as i0 from "@angular/core";
+export declare class StartEndDatetimeFormComponent implements OnChanges {
+    private readonly errorLogger;
+    private readonly modalController;
+    addSlotLabel?: string;
+    mode?: HappeningType;
+    date?: string;
+    timing: ITiming;
+    readonly timingChange: EventEmitter<ITiming>;
+    readonly addClick: EventEmitter<ITiming>;
+    durationInput?: IonInput;
+    protected readonly today: Date;
+    protected maxDate: string;
+    protected tab: 'duration' | 'end';
+    protected durationUnits: 'minutes' | 'hours';
+    protected readonly startDate: FormControl<string | null>;
+    protected readonly endDate: FormControl<string | null>;
+    protected readonly startTime: FormControl<string | null>;
+    protected readonly endTime: FormControl<string | null>;
+    protected readonly duration: FormControl<number | null>;
+    protected readonly form: UntypedFormGroup;
+    protected onTimingChanged(timing: ITiming): void;
+    protected get disabled(): boolean;
+    protected get hideStartDate(): boolean;
+    get isValid(): boolean;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    private onDateChanged;
+    private onTimingChange;
+    protected setStartTime(value: string): void;
+    protected addToStart(v: {
+        days?: number;
+        hours?: number;
+    }): void;
+    protected setStartDate(event: Event, code: 'today' | 'tomorrow'): void;
+    private emitTimingChanged;
+    protected addSlot(): void;
+    protected onStartTimeBlur(): void;
+    protected onStartDateChanged(): void;
+    protected onStartTimeChanged(): void;
+    protected onDurationChanged(): void;
+    private setEndTime;
+    protected onEndTimeChanged(): void;
+    private setDuration;
+    protected readonly isTomorrow: typeof isTomorrow;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StartEndDatetimeFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StartEndDatetimeFormComponent, "sneat-start-end-datetime-form", never, { "addSlotLabel": { "alias": "addSlotLabel"; "required": false; }; "mode": { "alias": "mode"; "required": true; }; "date": { "alias": "date"; "required": true; }; "timing": { "alias": "timing"; "required": true; }; }, { "timingChange": "timingChange"; "addClick": "addClick"; }, never, never, true, never>;
+}

package/lib/components/start-end-datetime-form/time-selector.component.d.ts

@@ -0,0 +1,15 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class TimeSelectorComponent {
+    private readonly modalController;
+    hideHeader: boolean;
+    readonly selected: EventEmitter<string>;
+    tab: 'morning' | 'day' | 'evening';
+    hours: string[];
+    constructor();
+    select(hh: string, mm: string): void;
+    close(): void;
+    onTabChanged(event: Event): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimeSelectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TimeSelectorComponent, "sneat-time-selector", never, { "hideHeader": { "alias": "hideHeader"; "required": false; }; }, { "selected": "selected"; }, never, never, true, never>;
+}

package/lib/components/swipeable-base.component.d.ts

@@ -0,0 +1,25 @@
+import { VirtualSliderAnimationStates } from '@sneat/components';
+import { SneatBaseComponent } from '@sneat/ui';
+import { IDateChanged, CalendarStateService } from './calendar/calendar-state.service';
+import { Parity, Swipeable } from './swipeable-ui';
+export declare abstract class SwipeableBaseComponent extends SneatBaseComponent {
+    protected readonly scheduleSateService: CalendarStateService;
+    private readonly stepDays;
+    shiftDays: number;
+    readonly $parity: import("@angular/core").WritableSignal<Parity>;
+    readonly $date: import("@angular/core").WritableSignal<Date>;
+    get dateAsIsoString(): string;
+    animationState?: VirtualSliderAnimationStates;
+    protected isEvenSlideActivated: boolean;
+    protected oddSlide?: Swipeable;
+    protected evenSlide?: Swipeable;
+    get activeSlide(): Swipeable | undefined;
+    protected constructor(scheduleSateService: CalendarStateService, stepDays: number);
+    protected readonly $isDefaultDate: import("@angular/core").Signal<boolean>;
+    protected swipeLeft(): void;
+    protected swipeNext(): void;
+    protected setToday(): void;
+    protected swipePrev(): void;
+    protected swipeRight(): void;
+    protected onDateChanged(changed: IDateChanged): void;
+}

package/lib/components/swipeable-ui.d.ts

@@ -0,0 +1,24 @@
+import { VirtualSlideAnimationsStates } from '@sneat/components';
+import { Weekday } from './calendar/weekday';
+import { Observable } from 'rxjs';
+import { CalendarDataProvider } from '../services/calendar-data-provider';
+import { IDateChanged } from './calendar/calendar-state.service';
+import { Week } from './week';
+export type Parity = 'odd' | 'even';
+export interface Swipeable {
+    readonly animationState: VirtualSlideAnimationsStates;
+    readonly parity: Parity;
+    readonly destroyed: Observable<void>;
+    readonly activeDateID: string;
+    readonly setDate: (changed: IDateChanged, animationState: VirtualSlideAnimationsStates) => Swipeable;
+}
+export declare function swipeableDay(parity: Parity, date: Date, spaceDaysProvider: CalendarDataProvider, destroyed: Observable<void>): SwipeableDay;
+export interface SwipeableDay extends Swipeable {
+    weekday: Weekday;
+    spaceDaysProvider: CalendarDataProvider;
+}
+export interface SwipeableWeek extends Swipeable, Week {
+    readonly startDate: Date;
+    readonly endDate: Date;
+}
+export declare function swipeableWeek(parity: Parity, date: Date, destroyed: Observable<void>): SwipeableWeek;

package/lib/components/week.d.ts

@@ -0,0 +1,4 @@
+export interface Week {
+    startDate: Date;
+    endDate: Date;
+}

package/lib/components/weekday-functions.d.ts

@@ -0,0 +1,3 @@
+import { CalendarDataProvider } from '../services/calendar-data-provider';
+import { Weekday } from './calendar/weekday';
+export declare function createWeekday(date: Date, spaceDaysProvider: CalendarDataProvider): Weekday;

package/lib/components/weekdays/weekdays-form-base.d.ts

@@ -0,0 +1,31 @@
+import { WeekdayCode2 } from '@sneat/mod-schedulus-core';
+import { SneatBaseComponent } from '@sneat/ui';
+export declare abstract class WeekdaysFormBase extends SneatBaseComponent {
+    protected readonly isWeekdayRequired: boolean;
+    protected readonly weekdayMo: import("@angular/core").WritableSignal<boolean>;
+    protected readonly weekdayTu: import("@angular/core").WritableSignal<boolean>;
+    protected readonly weekdayWe: import("@angular/core").WritableSignal<boolean>;
+    protected readonly weekdayTh: import("@angular/core").WritableSignal<boolean>;
+    protected readonly weekdayFr: import("@angular/core").WritableSignal<boolean>;
+    protected readonly weekdaySa: import("@angular/core").WritableSignal<boolean>;
+    protected readonly weekdaySu: import("@angular/core").WritableSignal<boolean>;
+    protected readonly hasWeekdaySelected: import("@angular/core").Signal<boolean>;
+    protected readonly weekdaysCheckbox: import("@angular/core").Signal<boolean>;
+    protected readonly weekendCheckbox: import("@angular/core").Signal<boolean>;
+    protected readonly allWeekdaysSelected: import("@angular/core").Signal<boolean>;
+    protected onWeekdaysCheckboxChange(checked: boolean): void;
+    private isWeekend;
+    protected onWeekendCheckboxChange(checked: boolean): void;
+    protected onWeekdayChanged(wd: WeekdayCode2, checked: boolean): void;
+    protected readonly weekdayById: {
+        mo: import("@angular/core").WritableSignal<boolean>;
+        tu: import("@angular/core").WritableSignal<boolean>;
+        we: import("@angular/core").WritableSignal<boolean>;
+        th: import("@angular/core").WritableSignal<boolean>;
+        fr: import("@angular/core").WritableSignal<boolean>;
+        sa: import("@angular/core").WritableSignal<boolean>;
+        su: import("@angular/core").WritableSignal<boolean>;
+    };
+    protected readonly selectedWeekdayCodes: import("@angular/core").Signal<WeekdayCode2[]>;
+    protected constructor(isWeekdayRequired: boolean);
+}

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './components';
+export * from './services';

package/lib/modals/happening-title-modal/happening-title-modal.component.d.ts

@@ -0,0 +1,24 @@
+import { OnInit } from '@angular/core';
+import { FormControl, FormGroup } from '@angular/forms';
+import { IonInput } from '@ionic/angular/standalone';
+import { IHappeningContext } from '@sneat/mod-schedulus-core';
+import { SneatBaseModalComponent } from '@sneat/ui';
+import * as i0 from "@angular/core";
+export declare class HappeningTitleModalComponent extends SneatBaseModalComponent implements OnInit {
+    happening?: IHappeningContext;
+    titleInput?: IonInput;
+    protected readonly title: FormControl<string | null>;
+    protected readonly summary: FormControl<string | null>;
+    protected readonly description: FormControl<string | null>;
+    protected readonly form: FormGroup<{
+        title: FormControl<string | null>;
+    }>;
+    protected onEnter(_event?: Event): void;
+    private happeningService;
+    constructor();
+    ngOnInit(): void;
+    protected readonly $isSubmitting: import("@angular/core").WritableSignal<boolean>;
+    protected submit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HappeningTitleModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HappeningTitleModalComponent, "sneat-happening-title-modal", never, { "happening": { "alias": "happening"; "required": true; }; }, {}, never, never, true, never>;
+}