@sneat/contactus-shared 0.2.0

package/lib/components/contact-forms/new-contact/new-company-form.component.d.ts

@@ -0,0 +1,26 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import { FormControl, FormGroup } from '@angular/forms';
+import { ISelectItem } from '@sneat/ui';
+import { ContactRole, IContactContext, IContactWithOptionalDbo } from '@sneat/contactus-core';
+import { NewContactFormBaseComponent } from './new-contact-form-base.component';
+import * as i0 from "@angular/core";
+export declare class NewCompanyFormComponent extends NewContactFormBaseComponent implements OnChanges {
+    private readonly contactService;
+    contactRoles?: ISelectItem[];
+    contactRole?: ContactRole;
+    hideRole: boolean;
+    parentContact?: IContactContext;
+    protected readonly Object: ObjectConstructor;
+    protected isCreating: boolean;
+    protected contact?: IContactWithOptionalDbo;
+    protected readonly form: FormGroup<{
+        role: FormControl<ContactRole | null | undefined>;
+        title: FormControl<string | null>;
+    }>;
+    ngOnChanges(changes: SimpleChanges): void;
+    get formIsValid(): boolean;
+    onContactChanged(contact: IContactWithOptionalDbo): void;
+    create(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NewCompanyFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NewCompanyFormComponent, "sneat-new-company-form", never, { "contactRoles": { "alias": "contactRoles"; "required": false; }; "contactRole": { "alias": "contactRole"; "required": false; }; "hideRole": { "alias": "hideRole"; "required": false; }; "parentContact": { "alias": "parentContact"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/contact-forms/new-contact/new-contact-form-base.component.d.ts

@@ -0,0 +1,15 @@
+import { EventEmitter } from '@angular/core';
+import { ContactIdAndDboWithSpaceRef, IEmail, IPhone, NewContactBaseDboAndSpaceRef } from '@sneat/contactus-core';
+import { ContactFormBaseComponent } from '../contact-form-base.component';
+import * as i0 from "@angular/core";
+export declare abstract class NewContactFormBaseComponent extends ContactFormBaseComponent {
+    readonly $contact: import("@angular/core").InputSignal<NewContactBaseDboAndSpaceRef>;
+    protected readonly $contactType: import("@angular/core").Signal<import("@sneat/contactus-core").ContactType>;
+    protected readonly $emails: import("@angular/core").Signal<IEmail[]>;
+    protected readonly $phones: import("@angular/core").Signal<IPhone[]>;
+    readonly contactChange: EventEmitter<NewContactBaseDboAndSpaceRef>;
+    readonly creatingChange: EventEmitter<boolean>;
+    readonly contactCreated: EventEmitter<ContactIdAndDboWithSpaceRef>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NewContactFormBaseComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NewContactFormBaseComponent, never, never, { "$contact": { "alias": "$contact"; "required": true; "isSignal": true; }; }, { "contactChange": "contactChange"; "creatingChange": "creatingChange"; "contactCreated": "contactCreated"; }, never, never, true, never>;
+}

package/lib/components/contact-forms/new-contact/new-contact-form.component.d.ts

@@ -0,0 +1,20 @@
+import { OnInit } from '@angular/core';
+import { NewContactBaseDboAndSpaceRef } from '@sneat/contactus-core';
+import { Observable } from 'rxjs';
+import { IContactAddEventArgs } from '../../contact-events';
+import { NewContactFormBaseComponent } from './new-contact-form-base.component';
+import { NewContactFormCommand } from './new-person-form.component';
+import * as i0 from "@angular/core";
+type NewContactFormTab = 'person' | 'pet' | 'company' | 'location';
+export declare class NewContactFormComponent extends NewContactFormBaseComponent implements OnInit {
+    protected readonly $tab: import("@angular/core").WritableSignal<NewContactFormTab | undefined>;
+    command?: Observable<NewContactFormCommand>;
+    selectGroupAndRole$?: Observable<IContactAddEventArgs | undefined>;
+    private readonly injector;
+    ngOnInit(): void;
+    protected onTabChange(event: CustomEvent): void;
+    protected onContactChanged(contact: NewContactBaseDboAndSpaceRef): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NewContactFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NewContactFormComponent, "sneat-new-contact-form", never, { "command": { "alias": "command"; "required": false; }; "selectGroupAndRole$": { "alias": "selectGroupAndRole$"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/components/contact-forms/new-contact/new-person-form.component.d.ts

@@ -0,0 +1,51 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { IContactRoleWithIdAndBrief, ContactToAssetRelation, IContactGroupDbo, IPersonRequirements, ContactRole, IContactRoleWithIdAndOptionalBrief, NewContactBaseDboAndSpaceRef } from '@sneat/contactus-core';
+import { IContactAddEventArgs } from '../../contact-events';
+import { IIdAndDbo, IIdAndOptionalDbo } from '@sneat/core';
+import { IAssetContext } from '@sneat/mod-assetus-core';
+import { Observable } from 'rxjs';
+import { NewContactFormBaseComponent } from './new-contact-form-base.component';
+import * as i0 from "@angular/core";
+export type OptionalContactRoleIdAndBrief = IContactRoleWithIdAndBrief | undefined;
+export type OptionalContactGroupIdAndBrief = IIdAndOptionalDbo<IContactGroupDbo> | undefined;
+export type NewContactFormCommand = 'create' | 'reset';
+export declare class NewPersonFormComponent extends NewContactFormBaseComponent implements OnInit {
+    isInModal: boolean;
+    command?: Observable<NewContactFormCommand>;
+    selectGroupAndRole$?: Observable<IContactAddEventArgs | undefined>;
+    readonly $fixedGroupID: import("@angular/core").InputSignal<string | undefined>;
+    readonly $fixedRoleID: import("@angular/core").InputSignal<ContactRole | undefined>;
+    readonly $assetID: import("@angular/core").InputSignal<string | undefined>;
+    private readonly assetID$;
+    readonly $asset: import("@angular/core").WritableSignal<IAssetContext | undefined>;
+    protected readonly $selectedContactGroup: import("@angular/core").WritableSignal<OptionalContactGroupIdAndBrief>;
+    protected readonly $selectedContactGroupID: import("@angular/core").Signal<string | undefined>;
+    protected readonly $selectedContactRole: import("@angular/core").WritableSignal<IContactRoleWithIdAndOptionalBrief | undefined>;
+    protected readonly $selectedContactRoleID: import("@angular/core").Signal<ContactRole | undefined>;
+    readonly $parentContactID: import("@angular/core").InputSignal<string | undefined>;
+    private readonly parentContactID$;
+    private readonly $parentContact;
+    protected readonly personRequires: IPersonRequirements;
+    readonly contactRoleChange: EventEmitter<OptionalContactRoleIdAndBrief>;
+    readonly contactGroupChange: EventEmitter<OptionalContactGroupIdAndBrief>;
+    protected assetRelation?: ContactToAssetRelation;
+    protected readonly $personFormIsReadyToSubmit: import("@angular/core").WritableSignal<boolean>;
+    protected readonly $creating: import("@angular/core").WritableSignal<boolean>;
+    private readonly assetService;
+    private readonly contactGroupService;
+    private readonly contactService;
+    private readonly contactRoleService;
+    constructor();
+    ngOnInit(): void;
+    private readonly onSelectGroupAndRole;
+    private readonly onCommand;
+    private setupEffects;
+    protected onContactGroupChanged(contactGroup?: IIdAndDbo<IContactGroupDbo>): void;
+    protected onContactRoleIDChanged(contactRoleID?: string): void;
+    onContactChanged(contact: NewContactBaseDboAndSpaceRef): void;
+    onPersonFormIsReadyToSubmit(): void;
+    protected submit(): void;
+    protected readonly $isContactNotReady: import("@angular/core").Signal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NewPersonFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NewPersonFormComponent, "sneat-new-person-form", never, { "isInModal": { "alias": "isInModal"; "required": false; }; "command": { "alias": "command"; "required": false; }; "selectGroupAndRole$": { "alias": "selectGroupAndRole$"; "required": false; }; "$fixedGroupID": { "alias": "$fixedGroupID"; "required": false; "isSignal": true; }; "$fixedRoleID": { "alias": "$fixedRoleID"; "required": false; "isSignal": true; }; "$assetID": { "alias": "$assetID"; "required": false; "isSignal": true; }; "$parentContactID": { "alias": "$parentContactID"; "required": false; "isSignal": true; }; }, { "contactRoleChange": "contactRoleChange"; "contactGroupChange": "contactGroupChange"; }, never, never, true, never>;
+}

package/lib/components/contact-forms/new-contact/new-pet-form.component.d.ts

@@ -0,0 +1,8 @@
+import { NewContactBaseDboAndSpaceRef } from '@sneat/contactus-core';
+import { NewContactFormBaseComponent } from './new-contact-form-base.component';
+import * as i0 from "@angular/core";
+export declare class NewPetFormComponent extends NewContactFormBaseComponent {
+    protected onContactChanged(contact: NewContactBaseDboAndSpaceRef): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NewPetFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NewPetFormComponent, "sneat-new-pet-form", never, {}, {}, never, never, true, never>;
+}

package/lib/components/contact-forms/person-forms/age-group/age-group-form.component.d.ts

@@ -0,0 +1,17 @@
+import { EventEmitter } from '@angular/core';
+import { AgeGroupID, SpaceType } from '@sneat/core';
+import { ISelectItem } from '@sneat/ui';
+import * as i0 from "@angular/core";
+export declare class AgeGroupFormComponent {
+    spaceType?: SpaceType;
+    readonly $ageGroup: import("@angular/core").InputSignal<AgeGroupID | undefined>;
+    readonly ageGroupChange: EventEmitter<AgeGroupID | undefined>;
+    disabled: boolean;
+    readonly hidePetOption: import("@angular/core").InputSignal<boolean | undefined>;
+    readonly hideUndisclosedOption: import("@angular/core").InputSignal<boolean | undefined>;
+    protected $ageGroupLabel: import("@angular/core").Signal<"Adult or child?" | "Adult/child or pet?">;
+    protected readonly $ageGroupOptions: import("@angular/core").Signal<readonly ISelectItem[]>;
+    protected onAgeGroupChanged(ageGroup: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AgeGroupFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AgeGroupFormComponent, "sneat-age-group-form", never, { "spaceType": { "alias": "spaceType"; "required": true; }; "$ageGroup": { "alias": "$ageGroup"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; "hidePetOption": { "alias": "hidePetOption"; "required": false; "isSignal": true; }; "hideUndisclosedOption": { "alias": "hideUndisclosedOption"; "required": false; "isSignal": true; }; }, { "ageGroupChange": "ageGroupChange"; }, never, never, true, never>;
+}

package/lib/components/contact-forms/person-forms/age-group/index.d.ts

@@ -0,0 +1 @@
+export * from './age-group-form.component';

package/lib/components/contact-forms/person-forms/gender-form/gender-form.component.d.ts

@@ -0,0 +1,22 @@
+import { EventEmitter } from '@angular/core';
+import { Gender } from '@sneat/core';
+import { ISelectItem, SneatBaseComponent } from '@sneat/ui';
+import * as i0 from "@angular/core";
+export declare class GenderFormComponent extends SneatBaseComponent {
+    protected readonly genderOptions: readonly ISelectItem[];
+    lastItemLines?: 'none' | 'inset' | 'full';
+    hideSkipButton: boolean;
+    disabled: boolean;
+    readonly $spaceID: import("@angular/core").InputSignal<string>;
+    readonly $contactID: import("@angular/core").InputSignal<string | undefined>;
+    readonly $genderID: import("@angular/core").InputSignal<Gender | undefined>;
+    protected readonly $updatingToGender: import("@angular/core").WritableSignal<Gender | undefined>;
+    readonly genderChange: EventEmitter<Gender>;
+    private readonly contactService;
+    protected skip(): void;
+    protected readonly $isChanging: import("@angular/core").WritableSignal<boolean>;
+    private onGenderChanged;
+    protected onGenderIDChanged(genderID: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GenderFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GenderFormComponent, "sneat-gender-form", never, { "lastItemLines": { "alias": "lastItemLines"; "required": false; }; "hideSkipButton": { "alias": "hideSkipButton"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "$spaceID": { "alias": "$spaceID"; "required": true; "isSignal": true; }; "$contactID": { "alias": "$contactID"; "required": true; "isSignal": true; }; "$genderID": { "alias": "$genderID"; "required": true; "isSignal": true; }; }, { "genderChange": "genderChange"; }, never, never, true, never>;
+}

package/lib/components/contact-forms/person-forms/gender-form/index.d.ts

@@ -0,0 +1 @@
+export * from './gender-form.component';

package/lib/components/contact-forms/person-forms/names-form/index.d.ts

@@ -0,0 +1 @@
+export * from './names-form.component';

package/lib/components/contact-forms/person-forms/names-form/names-form.component.d.ts

@@ -0,0 +1,63 @@
+import { AfterViewInit, EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { AbstractControl, FormControl, FormGroup, ValidationErrors } from '@angular/forms';
+import { IonInput } from '@ionic/angular/standalone';
+import { IPersonNames } from '@sneat/auth-models';
+import { IFormField } from '@sneat/core';
+import * as i0 from "@angular/core";
+export interface INamesFormFields {
+    readonly firstName?: IFormField;
+    readonly middleName?: IFormField;
+    readonly lastName?: IFormField;
+    readonly nickName?: IFormField;
+    readonly fullName?: IFormField;
+}
+export declare class NamesFormComponent implements OnChanges, AfterViewInit {
+    showHeader: boolean;
+    name?: IPersonNames;
+    isActive: boolean;
+    disabled: boolean;
+    fields?: INamesFormFields;
+    showNextButton: boolean;
+    firstNameInput?: IonInput;
+    lastNameInput?: IonInput;
+    middleNameInput?: IonInput;
+    fullNameInput?: IonInput;
+    nickNameInput?: IonInput;
+    readonly keyupEnter: EventEmitter<Event>;
+    readonly namesChanged: EventEmitter<IPersonNames>;
+    readonly next: EventEmitter<Event>;
+    private initialNameChanged;
+    private isFullNameChanged;
+    private isViewInitiated;
+    private inputToFocus?;
+    private readonly errorLogger;
+    readonly fullName: FormControl<string | null>;
+    readonly firstName: FormControl<string | null>;
+    readonly middleName: FormControl<string | null>;
+    readonly lastName: FormControl<string | null>;
+    readonly nickName: FormControl<string | null>;
+    readonly isNamesFormValid: (control: AbstractControl) => ValidationErrors | null;
+    readonly namesForm: FormGroup<{
+        fullName: FormControl<string | null>;
+        firstName: FormControl<string | null>;
+        lastName: FormControl<string | null>;
+        middleName: FormControl<string | null>;
+        nickName: FormControl<string | null>;
+    }>;
+    private setFocusToInput;
+    ngOnChanges(changes: SimpleChanges): void;
+    private onInputChangeDisabled;
+    private onInputChangeName;
+    private onInputChangeFields;
+    ngAfterViewInit(): void;
+    onNameChanged(_event?: Event): void;
+    private setName;
+    names(): IPersonNames;
+    private generateFullName;
+    protected onFullNameChanged(_event?: Event): void;
+    protected nameKeyupEnter(event: Event): void;
+    protected get canGoNext(): boolean;
+    protected onNext(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NamesFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NamesFormComponent, "sneat-names-form", never, { "showHeader": { "alias": "showHeader"; "required": false; }; "name": { "alias": "name"; "required": true; }; "isActive": { "alias": "isActive"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "showNextButton": { "alias": "showNextButton"; "required": false; }; }, { "keyupEnter": "keyupEnter"; "namesChanged": "namesChanged"; "next": "next"; }, never, never, true, never>;
+}

package/lib/components/contact-forms/pesson-wizard/index.d.ts

@@ -0,0 +1 @@
+export * from './person-wizard.component';

package/lib/components/contact-forms/pesson-wizard/person-wizard.component.d.ts

@@ -0,0 +1,63 @@
+import { EventEmitter, OnChanges, OnInit, SimpleChanges } from '@angular/core';
+import { IPersonNames } from '@sneat/auth-models';
+import { AgeGroupID, Gender } from '@sneat/core';
+import { IFormField } from '@sneat/core';
+import { IEmail, IPersonRequirements, IPhone } from '@sneat/contactus-core';
+import { IRelatedTo, IRelationshipRoles, ISpaceModuleItemRef } from '@sneat/dto';
+import { UserSpaceBriefProvider } from '../../../providers/user-space-brief.provider';
+import { NewContactFormBaseComponent } from '../new-contact/new-contact-form-base.component';
+import { GenderFormComponent } from '../person-forms/gender-form';
+import { INamesFormFields, NamesFormComponent } from '../person-forms/names-form';
+import * as i0 from "@angular/core";
+export interface PersonWizardState {
+    readonly contactType?: boolean;
+    readonly ageGroup?: boolean;
+    readonly name?: boolean;
+    readonly nameNext?: boolean;
+    readonly gender?: boolean;
+    readonly roles?: boolean;
+    readonly relatedAs?: boolean;
+    readonly communicationChannels?: boolean;
+    readonly submitButton?: boolean;
+}
+export type IPersonFormWizardFields = {
+    [id in keyof PersonWizardState]: IFormField;
+};
+export declare class PersonWizardComponent extends NewContactFormBaseComponent implements OnInit, OnChanges {
+    private readonly userService;
+    requires: IPersonRequirements;
+    disabled: boolean;
+    hideRelationship: boolean;
+    hidePetOption: boolean;
+    displayAgeGroupValue: boolean;
+    nameFields: INamesFormFields;
+    readonly $fields: import("@angular/core").InputSignal<Readonly<IPersonFormWizardFields>>;
+    isReadyToSubmit: boolean;
+    readonly isReadyToSubmitChange: EventEmitter<boolean>;
+    show: PersonWizardState;
+    readonly $wizardStep: import("@angular/core").WritableSignal<keyof PersonWizardState>;
+    tab?: 'emails' | 'phones';
+    namesFormComponent?: NamesFormComponent;
+    genderFormComponent?: GenderFormComponent;
+    protected readonly $relatedToUser: import("@angular/core").Signal<ISpaceModuleItemRef | undefined>;
+    protected readonly $relatedTo: import("@angular/core").Signal<IRelatedTo | undefined>;
+    protected readonly userSpaceBrief: UserSpaceBriefProvider;
+    ngOnInit(): void;
+    private readonly formOrder;
+    ngOnChanges(changes: SimpleChanges): void;
+    private setContactData;
+    protected onNameChanged(name: IPersonNames): void;
+    protected onContactChanged(): void;
+    protected onGenderChanged(gender?: Gender): void;
+    private onContactTypeChanged;
+    protected onAgeGroupChanged(ageGroup?: AgeGroupID): void;
+    protected onEmailsChanged(emails: readonly IEmail[]): void;
+    protected onPhoneChanged(phones: readonly IPhone[]): void;
+    protected onRelatedAsChanged(rolesToTarget: IRelationshipRoles): void;
+    protected nextFromName(event: Event): void;
+    private skipStep;
+    protected openNext(currentStepID: keyof PersonWizardState): void;
+    private stepHasValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PersonWizardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PersonWizardComponent, "sneat-person-wizard", never, { "requires": { "alias": "requires"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "hideRelationship": { "alias": "hideRelationship"; "required": false; }; "hidePetOption": { "alias": "hidePetOption"; "required": false; }; "displayAgeGroupValue": { "alias": "displayAgeGroupValue"; "required": false; }; "nameFields": { "alias": "nameFields"; "required": false; }; "$fields": { "alias": "$fields"; "required": true; "isSignal": true; }; }, { "isReadyToSubmitChange": "isReadyToSubmitChange"; }, never, never, true, never>;
+}

package/lib/components/contact-forms/pet-kind-and-breed-form/index.d.ts

@@ -0,0 +1 @@
+export * from './pet-kind-and-breed-form.component';

package/lib/components/contact-forms/pet-kind-and-breed-form/pet-kind-and-breed-form.component.d.ts

@@ -0,0 +1,14 @@
+import { EventEmitter } from '@angular/core';
+import { ISelectItem } from '@sneat/ui';
+import { EditContactFormBaseComponent } from '../contact-form-base.component';
+import * as i0 from "@angular/core";
+export declare class PetKindAndBreedFormComponent extends EditContactFormBaseComponent {
+    readonly petKindChange: EventEmitter<"dog" | "cat" | "hamster" | "rabbit" | "bird" | "fish" | "turtle" | "snake" | "lizard" | "horse" | "pig" | "cow" | undefined>;
+    protected breeds: readonly ISelectItem[];
+    protected readonly petKinds: ISelectItem[];
+    constructor();
+    protected onPetKindChanged(petKind: string): void;
+    protected onPetBreedChanged(petBreed: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PetKindAndBreedFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PetKindAndBreedFormComponent, "sneat-pet-kind-and-breed-form", never, {}, { "petKindChange": "petKindChange"; }, never, never, true, never>;
+}

package/lib/components/contact-forms/phones-form/index.d.ts

@@ -0,0 +1 @@
+export * from './phones-form.component';

package/lib/components/contact-forms/phones-form/phones-form.component.d.ts

@@ -0,0 +1,21 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { IPhone } from '@sneat/contactus-core';
+import * as i0 from "@angular/core";
+type PhoneType = 'personal' | 'mobile' | 'work' | 'fax' | 'landline';
+export declare class PhonesFormComponent implements OnChanges {
+    disabled: boolean;
+    hideHeader: boolean;
+    isActiveInWizard: boolean;
+    readonly types: {
+        id: PhoneType;
+        title: string;
+    }[];
+    phones?: IPhone[];
+    readonly phonesChange: EventEmitter<IPhone[]>;
+    ngOnChanges(changes: SimpleChanges): void;
+    typeChanged(event: Event, i: number): void;
+    numberChanged(event: Event, i: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PhonesFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PhonesFormComponent, "sneat-phones-form", never, { "disabled": { "alias": "disabled"; "required": false; }; "hideHeader": { "alias": "hideHeader"; "required": false; }; "isActiveInWizard": { "alias": "isActiveInWizard"; "required": false; }; "phones": { "alias": "phones"; "required": false; }; }, { "phonesChange": "phonesChange"; }, never, never, true, never>;
+}
+export {};

package/lib/components/contact-forms/relationship-form/contact-relationship-form.component.d.ts

@@ -0,0 +1,24 @@
+import { EventEmitter } from '@angular/core';
+import { AgeGroupID } from '@sneat/core';
+import { WithSpaceInput } from '@sneat/space-services';
+import { IRelatedChange } from '@sneat/space-models';
+import { ISelectItem } from '@sneat/ui';
+import { IRelatedTo, ISpaceModuleItemRef, WritableRelationshipRoles } from '@sneat/dto';
+import * as i0 from "@angular/core";
+export declare class ContactRelationshipFormComponent extends WithSpaceInput {
+    readonly $contactID: import("@angular/core").InputSignal<string | undefined>;
+    protected readonly $itemRef: import("@angular/core").Signal<ISpaceModuleItemRef | undefined>;
+    readonly $ageGroup: import("@angular/core").InputSignal<AgeGroupID | undefined>;
+    readonly $relatedTo: import("@angular/core").InputSignal<IRelatedTo | undefined>;
+    readonly $isProcessing: import("@angular/core").WritableSignal<boolean>;
+    readonly $userSpaceContactID: import("@angular/core").InputSignal<string | null | undefined>;
+    isActive: boolean;
+    disabled: boolean;
+    readonly relatedAsChange: EventEmitter<Readonly<WritableRelationshipRoles>>;
+    private readonly spaceService;
+    constructor();
+    protected onRelatedAsChanged(relatedChange: IRelatedChange): void;
+    protected $relationshipOptions: import("@angular/core").Signal<ISelectItem[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContactRelationshipFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContactRelationshipFormComponent, "sneat-contact-relationship-form", never, { "$contactID": { "alias": "$contactID"; "required": true; "isSignal": true; }; "$ageGroup": { "alias": "$ageGroup"; "required": true; "isSignal": true; }; "$relatedTo": { "alias": "$relatedTo"; "required": true; "isSignal": true; }; "$userSpaceContactID": { "alias": "$userSpaceContactID"; "required": true; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "relatedAsChange": "relatedAsChange"; }, never, never, true, never>;
+}

package/lib/components/contact-forms/relationship-form/index.d.ts

@@ -0,0 +1 @@
+export * from './relationship-form.component';

package/lib/components/contact-forms/relationship-form/relationship-form.component.d.ts

@@ -0,0 +1,34 @@
+import { EventEmitter } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { IRelatedTo, IRelationshipRole, ISpaceModuleItemRef } from '@sneat/dto';
+import { IRelatedChange } from '@sneat/space-models';
+import { ISelectItem } from '@sneat/ui';
+import { SpaceRelatedFormComponent } from '../space-related-form.component';
+import * as i0 from "@angular/core";
+interface IRelationshipWithID extends IRelationshipRole {
+    readonly id: string;
+}
+export declare class RelationshipFormComponent extends SpaceRelatedFormComponent {
+    private readonly userService;
+    readonly $itemRef: import("@angular/core").InputSignal<ISpaceModuleItemRef | undefined>;
+    readonly $relatedTo: import("@angular/core").InputSignal<IRelatedTo | undefined>;
+    readonly $relationshipOptions: import("@angular/core").InputSignal<readonly ISelectItem[] | undefined>;
+    readonly $isProcessing: import("@angular/core").InputSignal<boolean | undefined>;
+    protected readonly $rolesOfItemRelatedToTarget: import("@angular/core").Signal<readonly IRelationshipWithID[] | undefined>;
+    protected readonly $relationshipsCount: import("@angular/core").Signal<number>;
+    protected readonly $hasRelationships: import("@angular/core").Signal<boolean>;
+    protected readonly $useSelect: import("@angular/core").Signal<boolean>;
+    readonly relatedAsChange: EventEmitter<IRelatedChange>;
+    isActive: boolean;
+    disabled: boolean;
+    protected readonly relatedAsSingle: FormControl<string | null>;
+    private readonly spaceService;
+    protected readonly label = "Related to me as";
+    protected onRelationshipChanged(value: string): void;
+    maxNumberOfRelationships: number;
+    protected openAddRelationship(event: Event): void;
+    protected removeRelationship(event: Event, id: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RelationshipFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RelationshipFormComponent, "sneat-relationship-form", never, { "$itemRef": { "alias": "$itemRef"; "required": true; "isSignal": true; }; "$relatedTo": { "alias": "$relatedTo"; "required": true; "isSignal": true; }; "$relationshipOptions": { "alias": "$relationshipOptions"; "required": true; "isSignal": true; }; "$isProcessing": { "alias": "$isProcessing"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "maxNumberOfRelationships": { "alias": "maxNumberOfRelationships"; "required": false; }; }, { "relatedAsChange": "relatedAsChange"; }, never, never, true, never>;
+}
+export {};

package/lib/components/contact-forms/role-form/contact-role-form.component.d.ts

@@ -0,0 +1,33 @@
+import { EventEmitter } from '@angular/core';
+import { IIdAndDbo } from '@sneat/core';
+import { ContactRole, IContactGroupDbo, IContactRoleWithIdAndBrief } from '@sneat/contactus-core';
+import { SneatBaseComponent } from '@sneat/ui';
+import * as i0 from "@angular/core";
+export declare class ContactRoleFormComponent extends SneatBaseComponent {
+    $contactGroupID: import("@angular/core").InputSignal<string | undefined>;
+    protected $contactGroup: import("@angular/core").Signal<IIdAndDbo<IContactGroupDbo> | undefined>;
+    readonly contactGroupIDChange: EventEmitter<string | undefined>;
+    readonly contactGroupChange: EventEmitter<IIdAndDbo<IContactGroupDbo> | undefined>;
+    readonly $contactRoleID: import("@angular/core").InputSignal<ContactRole | undefined>;
+    readonly contactRoleIDChange: EventEmitter<ContactRole | undefined>;
+    readonly contactRoleChange: EventEmitter<IContactRoleWithIdAndBrief | undefined>;
+    protected readonly $groups: import("@angular/core").WritableSignal<readonly IIdAndDbo<IContactGroupDbo>[] | undefined>;
+    protected readonly $groupItems: import("@angular/core").Signal<{
+        id: string;
+        title: string;
+        emoji: string | undefined;
+    }[]>;
+    protected readonly $roleItems: import("@angular/core").Signal<{
+        id: ContactRole;
+        title: string;
+        emoji: string | undefined;
+    }[] | undefined>;
+    protected readonly roleBriefID: (o: IContactRoleWithIdAndBrief) => ContactRole;
+    protected readonly groupID: (_: number, o: IIdAndDbo<IContactGroupDbo>) => string;
+    constructor();
+    protected onContactGroupIDChanged(contactGroupID: string): void;
+    protected onContactRoleIDChanged(contactRoleID: string): void;
+    protected clearContactType(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContactRoleFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContactRoleFormComponent, "sneat-contact-role-form", never, { "$contactGroupID": { "alias": "$contactGroupID"; "required": true; "isSignal": true; }; "$contactRoleID": { "alias": "$contactRoleID"; "required": true; "isSignal": true; }; }, { "contactGroupIDChange": "contactGroupIDChange"; "contactGroupChange": "contactGroupChange"; "contactRoleIDChange": "contactRoleIDChange"; "contactRoleChange": "contactRoleChange"; }, never, never, true, never>;
+}

package/lib/components/contact-forms/role-form/index.d.ts

@@ -0,0 +1 @@
+export * from './contact-role-form.component';

package/lib/components/contact-forms/roles-form/index.d.ts

@@ -0,0 +1 @@
+export * from './roles-form.component';

package/lib/components/contact-forms/roles-form/roles-form.component.d.ts

@@ -0,0 +1,21 @@
+import { EventEmitter } from '@angular/core';
+import { ISpaceContext } from '@sneat/space-models';
+import { SpaceRelatedFormComponent } from '../space-related-form.component';
+import * as i0 from "@angular/core";
+interface Role {
+    checked?: boolean;
+    id: string;
+    title: string;
+    icon: string;
+}
+export declare class RolesFormComponent extends SpaceRelatedFormComponent {
+    isActive: boolean;
+    disabled: boolean;
+    roles?: Role[];
+    readonly rolesChange: EventEmitter<string[]>;
+    protected onSpaceTypeChanged(space?: ISpaceContext): void;
+    roleChecked(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RolesFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RolesFormComponent, "sneat-roles-form", never, { "isActive": { "alias": "isActive"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "rolesChange": "rolesChange"; }, never, never, true, never>;
+}
+export {};

package/lib/components/contact-forms/space-related-form.component.d.ts

@@ -0,0 +1,11 @@
+import { OnChanges, SimpleChange, SimpleChanges } from '@angular/core';
+import { WithSpaceInput } from '@sneat/space-services';
+import { ISpaceContext } from '@sneat/space-models';
+import * as i0 from "@angular/core";
+export declare abstract class SpaceRelatedFormComponent extends WithSpaceInput implements OnChanges {
+    ngOnChanges(changes: SimpleChanges): void;
+    protected onSpaceChanged(teamChange: SimpleChange): void;
+    protected onSpaceTypeChanged(_space?: ISpaceContext): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpaceRelatedFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpaceRelatedFormComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}

package/lib/components/contact-input/contact-input.component.d.ts

@@ -0,0 +1,36 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { ContactRole, ContactType, IContactContext } from '@sneat/contactus-core';
+import { ISpaceContext } from '@sneat/space-models';
+import * as i0 from "@angular/core";
+export declare class ContactInputComponent implements OnChanges {
+    private readonly errorLogger;
+    private readonly contactSelectorService;
+    space?: ISpaceContext;
+    disabled?: boolean;
+    canChangeContact: boolean;
+    canReset: boolean;
+    readonly: boolean;
+    label?: string;
+    labelPosition?: 'fixed' | 'stacked' | 'floating';
+    contactRole?: ContactRole;
+    contactType?: ContactType;
+    subLabel: string;
+    parentType?: ContactType;
+    parentRole?: ContactRole;
+    parentContact?: IContactContext;
+    deleting: boolean;
+    contact?: IContactContext;
+    readonly contactChange: EventEmitter<IContactContext | undefined>;
+    protected readonly labelText: () => string;
+    protected get showFlag(): boolean;
+    protected get showParentFlag(): boolean;
+    protected parentTitle(): string;
+    protected contactTitle(): string;
+    private getTitle;
+    ngOnChanges(changes: SimpleChanges): void;
+    get contactLink(): string;
+    reset(event: Event): void;
+    openContactSelector(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContactInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContactInputComponent, "sneat-contact-input", never, { "space": { "alias": "space"; "required": true; }; "disabled": { "alias": "disabled"; "required": false; }; "canChangeContact": { "alias": "canChangeContact"; "required": false; }; "canReset": { "alias": "canReset"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "label": { "alias": "label"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "contactRole": { "alias": "contactRole"; "required": false; }; "contactType": { "alias": "contactType"; "required": false; }; "subLabel": { "alias": "subLabel"; "required": false; }; "parentType": { "alias": "parentType"; "required": false; }; "parentRole": { "alias": "parentRole"; "required": false; }; "parentContact": { "alias": "parentContact"; "required": false; }; "deleting": { "alias": "deleting"; "required": false; }; "contact": { "alias": "contact"; "required": false; }; }, { "contactChange": "contactChange"; }, never, never, true, never>;
+}

package/lib/components/contact-input/index.d.ts

@@ -0,0 +1 @@
+export * from './contact-input.component';

package/lib/components/contact-locations/contact-locations.component.d.ts

@@ -0,0 +1,14 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import { IIdAndBriefAndOptionalDbo } from '@sneat/core';
+import { IContactBrief, IContactDbo, IContactWithCheck } from '@sneat/contactus-core';
+import { ISpaceContext } from '@sneat/space-models';
+import * as i0 from "@angular/core";
+export declare class ContactLocationsComponent implements OnChanges {
+    readonly $space: import("@angular/core").InputSignal<ISpaceContext>;
+    contact?: IIdAndBriefAndOptionalDbo<IContactBrief, IContactDbo>;
+    protected readonly $contactLocations: import("@angular/core").WritableSignal<readonly IContactWithCheck[]>;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getContactLocations;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContactLocationsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContactLocationsComponent, "sneat-contact-locations", never, { "$space": { "alias": "$space"; "required": true; "isSignal": true; }; "contact": { "alias": "contact"; "required": true; }; }, {}, never, never, true, never>;
+}

package/lib/components/contact-locations/index.d.ts

@@ -0,0 +1 @@
+export * from './contact-locations.component';

package/lib/components/contact-modules-menu/contact-modules-menu.component.d.ts

@@ -0,0 +1,12 @@
+import { ISneatExtension } from '@sneat/core';
+import { IContactWithBrief } from '@sneat/contactus-core';
+import { WithSpaceInput } from '@sneat/space-services';
+import * as i0 from "@angular/core";
+export declare class ContactModulesMenuComponent extends WithSpaceInput {
+    contact?: IContactWithBrief;
+    readonly extensions: ISneatExtension[];
+    protected goExt(ext: ISneatExtension): void;
+    protected goNew(event: Event, ext: ISneatExtension): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContactModulesMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContactModulesMenuComponent, "sneat-contact-modules-menu", never, { "contact": { "alias": "contact"; "required": true; }; }, {}, never, never, true, never>;
+}

package/lib/components/contact-modules-menu/index.d.ts

@@ -0,0 +1 @@
+export * from './contact-modules-menu.component';

package/lib/components/contact-role-badges/contact-role-badges.component.d.ts

@@ -0,0 +1,12 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ContactRoleBadgesComponent implements OnChanges {
+    private readonly alwaysHide;
+    roles?: readonly string[];
+    hideRoles: readonly string[];
+    private hiddenRoles;
+    protected _roles: readonly string[];
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContactRoleBadgesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContactRoleBadgesComponent, "sneat-contact-role-badges", never, { "roles": { "alias": "roles"; "required": true; }; "hideRoles": { "alias": "hideRoles"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/contact-roles-input/contact-roles-input.component.d.ts

@@ -0,0 +1,18 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import { IContactRole } from '@sneat/app';
+import { ContactRole, IContactWithBrief } from '@sneat/contactus-core';
+import { ISpaceContext } from '@sneat/space-models';
+import * as i0 from "@angular/core";
+export declare class ContactRolesInputComponent implements OnChanges {
+    private readonly errorLogger;
+    private readonly contactService;
+    private readonly contactRolesByType;
+    space?: ISpaceContext;
+    contact?: IContactWithBrief;
+    protected roles?: IContactRole[];
+    protected processingRoleIDs: ContactRole[];
+    ngOnChanges(changes: SimpleChanges): void;
+    private setRoles;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContactRolesInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContactRolesInputComponent, "sneat-contact-roles-input", never, { "space": { "alias": "space"; "required": true; }; "contact": { "alias": "contact"; "required": false; }; }, {}, never, never, true, never>;
+}