@agendize/js-agendize-api 1.28.0

package/dist/repository/index.d.ts

@@ -0,0 +1,84 @@
+import { AgendizeError } from "@/data/Error";
+import { Logger } from "@/utils/logger";
+import { Channel } from "type-pubsub";
+export declare const SHORT_CACHE_DURATION_MS = 60000;
+export declare const LONG_CACHE_DURATION_MS = 120000;
+export declare enum EMITTER_TYPE {
+    DELETE = 0,
+    UPDATE = 1,
+    CREATE = 2
+}
+export declare enum QUERY_TYPE {
+    REMOTE_THEN_LOCAL = 0,
+    LOCAL_THEN_REMOTE = 1,
+    LOCAL_ONLY = 2,
+    REMOTE_ONLY = 3
+}
+export interface QUERY_RESULT<T> {
+    result: T | undefined;
+    local: boolean;
+}
+export interface QUERY_RESULTS<T> {
+    results: T[];
+    nextSyncToken?: string;
+    local: boolean;
+}
+export interface QUERY_PAGINATED_RESULT<T> {
+    items: T[];
+    nextPageToken?: string;
+    nextSyncToken?: number;
+    totalItems?: number;
+}
+export declare const SERVICE_CHANNEL: Channel<EMITTER_TYPE>;
+export declare const STAFF_CHANNEL: Channel<EMITTER_TYPE>;
+export declare const STAFF_GROUP_CHANNEL: Channel<EMITTER_TYPE>;
+export declare const COMPANY_CHANNEL: Channel<EMITTER_TYPE>;
+export declare const SCHEDULING_RIGHTS_CHANNEL: Channel<EMITTER_TYPE>;
+export declare const ACCOUNT_CHANNEL: Channel<EMITTER_TYPE>;
+export declare const CONTACT_CHANNEL: Channel<EMITTER_TYPE>;
+export declare const EVENT_CHANNEL: Channel<EMITTER_TYPE>;
+export declare const RIGHT_CHANNEL: Channel<EMITTER_TYPE>;
+export declare const SERVICE_RESOURCE_CHANNEL: Channel<EMITTER_TYPE>;
+export declare const USER_CHANNEL: Channel<EMITTER_TYPE>;
+export declare const CONFERENCE_CHANNEL: Channel<EMITTER_TYPE>;
+export declare const CONFERENCE_TAG_CHANNEL: Channel<EMITTER_TYPE>;
+export declare const CONFERENCE_SESSION_CHANNEL: Channel<EMITTER_TYPE>;
+export declare abstract class Repository<T, A> {
+    readonly repositoryName: string;
+    readonly logger?: Logger;
+    readonly cacheDuration?: number;
+    protected static lastRemoteList: {
+        [key: string]: number;
+    };
+    constructor(repositoryName: string, logger?: Logger, cacheDuration?: number);
+    protected abstract remoteGet(bearer: string, args: A): Promise<T>;
+    protected abstract remoteList(bearer: string, args: A): Promise<T[]>;
+    protected abstract remoteCreate(bearer: string, args: A, item: T): Promise<T>;
+    protected abstract remoteUpdate(bearer: string, args: A, item: T): Promise<T>;
+    protected abstract remoteDelete(bearer: string, args: A): Promise<void>;
+    protected abstract localList(args: A): Promise<T[]>;
+    protected abstract localGet(args: A): Promise<T>;
+    protected abstract localBulkSave(args: A, items: T[]): Promise<void>;
+    protected abstract localDelete(args: A): Promise<void>;
+    protected abstract localBulkDelete(items: T[]): Promise<void>;
+    static cleanLastRemoteList(): void;
+    expireDb(): void;
+    protected list(bearer: string, queryType: QUERY_TYPE, args: A, authenticated?: boolean): Promise<QUERY_RESULTS<T>>;
+    protected update(bearer: string, queryType: QUERY_TYPE, args: A, item: T): Promise<T>;
+    protected create(bearer: string, queryType: QUERY_TYPE, args: A, item: T): Promise<T>;
+    protected getById(bearer: string, mode: QUERY_TYPE, args: A, authenticated?: boolean): Promise<QUERY_RESULT<T>>;
+    protected deleteById(bearer: string, args: A, authenticated?: boolean): Promise<void>;
+    protected cascadeDeleteList(args: A, predicate: (item: T) => boolean): Promise<void>;
+    protected cascadeDeleteItem(args: A): Promise<void>;
+    protected cascadeDelete(args: A, predicate?: (item: T) => boolean, list?: boolean): Promise<void>;
+    private _getLocalFirstThenRemote;
+    private _getRemoteFirstThenLocal;
+    private _listRemoteFirstThenLocal;
+    private _listLocalFirstThenRemote;
+    private _createRemoteFirstThenLocal;
+    private _updateRemoteFirstThenLocal;
+    private localSaveList;
+    private localSave;
+    protected _isExpired(lastRemote: number | undefined): boolean;
+    getError(e: unknown): AgendizeError;
+}

package/dist/repository/public/accountPublicRepository.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Copyright 2022 Agendize All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at.
+ *
+ *      Http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { QUERY_RESULT, Repository } from '@/repository';
+import { Logger } from '@/utils/logger';
+import { AccountPublicEntity } from "@/data/Account";
+interface Args {
+    userId: string;
+    locale?: string;
+}
+export declare class AccountPublicRepository extends Repository<AccountPublicEntity, Args> {
+    private accountPublicService;
+    constructor(baseURL: string, logger?: Logger);
+    dispose(): void;
+    getAccount(userId: string, locale?: string): Promise<QUERY_RESULT<AccountPublicEntity>>;
+    protected remoteGet(bearer: string, args: Args): Promise<AccountPublicEntity>;
+    protected localBulkDelete(items: AccountPublicEntity[]): Promise<void>;
+    protected localBulkSave(args: Args, items: AccountPublicEntity[]): Promise<void>;
+    protected localDelete(args: Args): Promise<void>;
+    protected localGet(args: Args): Promise<AccountPublicEntity>;
+    protected localList(args: Args): Promise<AccountPublicEntity[]>;
+    protected remoteCreate(bearer: string, args: Args, item: AccountPublicEntity): Promise<AccountPublicEntity>;
+    protected remoteDelete(bearer: string, args: Args): Promise<void>;
+    protected remoteList(bearer: string, args: Args): Promise<AccountPublicEntity[]>;
+    protected remoteUpdate(bearer: string, args: Args, item: AccountPublicEntity): Promise<AccountPublicEntity>;
+}
+export {};

package/dist/repository/public/companyPublicRepository.d.ts

@@ -0,0 +1,23 @@
+import { QUERY_RESULT, Repository } from "@/repository";
+import { CompanyPublicEntity } from "@/data/Company";
+import { Logger } from "@/utils/logger";
+interface Args {
+    companyId?: string;
+    companySelector?: boolean;
+}
+export declare class CompanyPublicRepository extends Repository<CompanyPublicEntity, Args> {
+    private companyPublicService;
+    constructor(baseURL: string, logger?: Logger);
+    getCompany(companyId: string, companySelector?: boolean): Promise<QUERY_RESULT<CompanyPublicEntity>>;
+    protected remoteGet(bearer: string, args: Args): Promise<CompanyPublicEntity>;
+    protected localBulkDelete(items: CompanyPublicEntity[]): Promise<void>;
+    protected localBulkSave(args: Args, items: CompanyPublicEntity[]): Promise<void>;
+    protected localDelete(args: Args): Promise<void>;
+    protected localGet(args: Args): Promise<CompanyPublicEntity>;
+    protected localList(args: Args): Promise<CompanyPublicEntity[]>;
+    protected remoteCreate(bearer: string, args: Args, item: CompanyPublicEntity): Promise<CompanyPublicEntity>;
+    protected remoteDelete(bearer: string, args: Args): Promise<void>;
+    protected remoteList(bearer: string, args: Args): Promise<CompanyPublicEntity[]>;
+    protected remoteUpdate(bearer: string, args: Args, item: CompanyPublicEntity): Promise<CompanyPublicEntity>;
+}
+export {};

package/dist/repository/public/conferencePublicRepository.d.ts

@@ -0,0 +1,26 @@
+import { ConferenceLightEntity, ConferenceListEntity } from "@/data/conference/Conference";
+import { QUERY_RESULT, Repository } from "@/repository";
+import { AuthenticationSecuredService } from "@/service/secured/authenticationSecuredService";
+import { Logger } from "@/utils/logger";
+export declare class Args {
+    accountId: string;
+    tagIds?: string[];
+    accountTagIds?: string[];
+    cipherParams?: string;
+}
+export declare class ConferencePublicRepository extends Repository<ConferenceListEntity, Args> {
+    private conferencePublicService;
+    constructor(authenticationService: AuthenticationSecuredService, baseURL: string, logger?: Logger);
+    getAllConferences(accountId: string, tagIds?: string[], accountTagIds?: string[], cipherParams?: string): Promise<QUERY_RESULT<ConferenceListEntity>>;
+    searchInAllConferences(accountId: string, start?: Date, end?: Date, tagIds?: string[], locations?: string[], accountIds?: string[], accountTagIds?: string[], cipherParams?: string): Promise<ConferenceLightEntity[]>;
+    protected localBulkDelete(items: ConferenceListEntity[]): Promise<void>;
+    protected localBulkSave(args: any, items: ConferenceListEntity[]): Promise<void>;
+    protected localDelete(args: any): Promise<void>;
+    protected localGet(args: any): Promise<ConferenceListEntity>;
+    protected localList(args: any): Promise<ConferenceListEntity[]>;
+    protected remoteCreate(bearer: string, args: any, item: ConferenceListEntity): Promise<ConferenceListEntity>;
+    protected remoteDelete(bearer: string, args: any): Promise<void>;
+    protected remoteGet(bearer: string, args: any): Promise<ConferenceListEntity>;
+    protected remoteList(bearer: string, args: any): Promise<ConferenceListEntity[]>;
+    protected remoteUpdate(bearer: string, args: any, item: ConferenceListEntity): Promise<ConferenceListEntity>;
+}

package/dist/repository/public/customStatusPublicRepository.d.ts

@@ -0,0 +1,28 @@
+import { QUERY_RESULT, QUERY_RESULTS, Repository } from "@/repository";
+import { CustomStatusEntity } from "@/data/CustomStatus";
+import { Logger } from "@/utils/logger";
+interface Args {
+    accountId: string;
+    eventId: string;
+    securityKey: string;
+}
+export declare class CustomStatusPublicRepository extends Repository<CustomStatusEntity, Args> {
+    private customStatusPublicService;
+    constructor(baseURL: string, logger?: Logger);
+    getAllCustomStatus(accountId: string, eventId: string, securityKey: string): Promise<QUERY_RESULTS<CustomStatusEntity>>;
+    protected remoteList(bearer: string, args: Args): Promise<CustomStatusEntity[]>;
+    getCustomStatus(): Promise<QUERY_RESULT<CustomStatusEntity>>;
+    createCustomStatus(): Promise<CustomStatusEntity>;
+    updateCustomStatus(): Promise<CustomStatusEntity>;
+    deleteCustomStatus(): Promise<void>;
+    protected remoteGet(): Promise<CustomStatusEntity>;
+    protected remoteCreate(): Promise<CustomStatusEntity>;
+    protected remoteUpdate(): Promise<CustomStatusEntity>;
+    protected remoteDelete(): Promise<void>;
+    protected localList(): Promise<CustomStatusEntity[]>;
+    protected localGet(): Promise<CustomStatusEntity>;
+    protected localBulkSave(): Promise<void>;
+    protected localDelete(): Promise<void>;
+    protected localBulkDelete(): Promise<void>;
+}
+export {};

package/dist/repository/public/eventPublicRepository.d.ts

@@ -0,0 +1,39 @@
+import { Repository } from "@/repository";
+import { EventPublicEntity } from "@/data/Event";
+import { Logger } from "@/utils/logger";
+interface Args {
+    accountId: string;
+    eventId: string;
+    companyId?: string;
+    securityKey: string;
+    locale?: string;
+    timeZone?: string;
+}
+export declare class EventPublicRepository extends Repository<EventPublicEntity, Args> {
+    private eventPublicService;
+    constructor(baseURL: string, logger?: Logger);
+    getEventById(accountId: string, eventId: string, securityKey: string, locale?: string): Promise<EventPublicEntity>;
+    updateEventStatus(accountId: string, companyId: string, eventId: string, securityKey: string, status: {
+        status?: string;
+        customStatus?: string;
+    }, locale?: string): Promise<EventPublicEntity>;
+    updateEventNotes(accountId: string, eventId: string, securityKey: string, notes: string, locale?: string): Promise<EventPublicEntity>;
+    rescheduleEvent(accountId: string, companyId: string, eventId: string, startDate: Date, securityKey: string, timeZone?: string, locale?: string): Promise<EventPublicEntity>;
+    protected remoteGet(bearer: string, args: Args): Promise<EventPublicEntity>;
+    protected remoteUpdateStatus(args: Args, status: {
+        status?: string;
+        customStatus?: string;
+    }): Promise<EventPublicEntity>;
+    protected remoteUpdateNotes(args: Args, notes: string): Promise<EventPublicEntity>;
+    protected remoteRescheduleEvent(args: Args, startDate: Date): Promise<EventPublicEntity>;
+    protected localBulkDelete(items: EventPublicEntity[]): Promise<void>;
+    protected localBulkSave(args: any, items: EventPublicEntity[]): Promise<void>;
+    protected localDelete(args: any): Promise<void>;
+    protected localGet(args: any): Promise<EventPublicEntity>;
+    protected localList(args: any): Promise<EventPublicEntity[]>;
+    protected remoteCreate(bearer: string, args: any, item: EventPublicEntity): Promise<EventPublicEntity>;
+    protected remoteDelete(bearer: string, args: any): Promise<void>;
+    protected remoteList(bearer: string, args: any): Promise<EventPublicEntity[]>;
+    protected remoteUpdate(bearer: string, args: any, item: EventPublicEntity): Promise<EventPublicEntity>;
+}
+export {};

package/dist/repository/public/formPublicRepository.d.ts

@@ -0,0 +1,25 @@
+import { QUERY_RESULT, Repository } from "@/repository";
+import { FormBuilderPublicEntity } from "@/data/Form";
+import { Logger } from "@/utils/logger";
+import { FormResultPublicEntity } from "@/data/FormResult";
+interface Args {
+    formId: string;
+    cypherParams?: string;
+}
+export declare class FormPublicRepository extends Repository<FormBuilderPublicEntity, Args> {
+    private formService;
+    constructor(baseURL: string, logger?: Logger);
+    getForm(formId: string, cypherParams?: string): Promise<QUERY_RESULT<FormBuilderPublicEntity>>;
+    submitFormResult(formId: string, formSubmit: FormResultPublicEntity): Promise<FormResultPublicEntity>;
+    remoteGet(bearer: string, args: Args): Promise<FormBuilderPublicEntity>;
+    protected localBulkDelete(items: FormBuilderPublicEntity[]): Promise<void>;
+    protected localBulkSave(args: Args, items: FormBuilderPublicEntity[]): Promise<void>;
+    protected localDelete(args: Args): Promise<void>;
+    protected localGet(args: Args): Promise<FormBuilderPublicEntity>;
+    protected localList(args: Args): Promise<FormBuilderPublicEntity[]>;
+    protected remoteDelete(bearer: string, args: Args): Promise<void>;
+    protected remoteList(bearer: string, args: Args): Promise<FormBuilderPublicEntity[]>;
+    protected remoteUpdate(bearer: string, args: Args, item: FormBuilderPublicEntity): Promise<FormBuilderPublicEntity>;
+    protected remoteCreate(bearer: string, args: Args, item: FormBuilderPublicEntity): Promise<FormBuilderPublicEntity>;
+}
+export {};

package/dist/repository/public/freeSlotPublicRepository.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Copyright 2022 Agendize All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at.
+ *
+ *      Http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { QUERY_RESULT, Repository } from "@/repository";
+import { FreeSlotPublicEntity, FreeSlotsFilterOptions } from "@/data/FreeSlot";
+import { Logger } from "@/utils/logger";
+interface Args {
+    filterOptions: FreeSlotsFilterOptions;
+    account: string;
+    companyId: string;
+    serviceId: string;
+}
+export declare class FreeSlotPublicRepository extends Repository<FreeSlotPublicEntity, Args> {
+    private freeSlotPublicService;
+    constructor(baseURL: string, logger?: Logger);
+    getFreeSlots(account: string, companyId: string, serviceId: string, filterOptions: FreeSlotsFilterOptions): Promise<QUERY_RESULT<FreeSlotPublicEntity>>;
+    protected remoteGet(bearer: string, args: Args): Promise<FreeSlotPublicEntity>;
+    protected localBulkDelete(items: FreeSlotPublicEntity[]): Promise<void>;
+    protected localBulkSave(args: Args, items: FreeSlotPublicEntity[]): Promise<void>;
+    protected localDelete(args: Args): Promise<void>;
+    protected localGet(args: Args): Promise<FreeSlotPublicEntity>;
+    protected localList(args: Args): Promise<FreeSlotPublicEntity[]>;
+    protected remoteCreate(bearer: string, args: Args, item: FreeSlotPublicEntity): Promise<FreeSlotPublicEntity>;
+    protected remoteDelete(bearer: string, args: Args): Promise<void>;
+    protected remoteList(bearer: string, args: Args): Promise<FreeSlotPublicEntity[]>;
+    protected remoteUpdate(bearer: string, args: Args, item: FreeSlotPublicEntity): Promise<FreeSlotPublicEntity>;
+}
+export {};

package/dist/repository/public/queuePublicRepository.d.ts

@@ -0,0 +1,22 @@
+import { QUERY_RESULT, Repository } from "@/repository";
+import { QueuePublicEntity } from "@/data/Queue";
+import { Logger } from "@/utils/logger";
+interface Args {
+    queueId: string;
+}
+export declare class QueuePublicRepository extends Repository<QueuePublicEntity, Args> {
+    private queuePublicService;
+    constructor(baseURL: string, logger?: Logger);
+    getQueue(queueId: string): Promise<QUERY_RESULT<QueuePublicEntity>>;
+    remoteGet(bearer: string, args: Args): Promise<QueuePublicEntity>;
+    protected localBulkDelete(items: QueuePublicEntity[]): Promise<void>;
+    protected localBulkSave(args: Args, items: QueuePublicEntity[]): Promise<void>;
+    protected localDelete(args: Args): Promise<void>;
+    protected localGet(args: Args): Promise<QueuePublicEntity>;
+    protected localList(args: Args): Promise<QueuePublicEntity[]>;
+    protected remoteCreate(bearer: string, args: Args, item: QueuePublicEntity): Promise<QueuePublicEntity>;
+    protected remoteDelete(bearer: string, args: Args): Promise<void>;
+    protected remoteList(bearer: string, args: Args): Promise<QueuePublicEntity[]>;
+    protected remoteUpdate(bearer: string, args: Args, item: QueuePublicEntity): Promise<QueuePublicEntity>;
+}
+export {};

package/dist/repository/public/queueRegistrationPublicRepository.d.ts

@@ -0,0 +1,22 @@
+import { Repository } from "@/repository";
+import { QueueRegistrationPublicEntity, QueueRegistrationResultPublicEntity } from "@/data/QueueRegistration";
+import { Logger } from "@/utils/logger";
+interface Args {
+    queueId: string;
+}
+export declare class QueueRegistrationPublicRepository extends Repository<QueueRegistrationPublicEntity, Args> {
+    private queueInscriptionPublicService;
+    constructor(baseURL: string, logger?: Logger);
+    inscriptionToQueue(queueId: string, inscription: QueueRegistrationPublicEntity): Promise<QueueRegistrationResultPublicEntity>;
+    remoteCreate(bearer: string, args: Args, item: QueueRegistrationPublicEntity): Promise<QueueRegistrationPublicEntity>;
+    protected localBulkDelete(items: QueueRegistrationPublicEntity[]): Promise<void>;
+    protected localBulkSave(args: Args, items: QueueRegistrationPublicEntity[]): Promise<void>;
+    protected localDelete(args: Args): Promise<void>;
+    protected localGet(args: Args): Promise<QueueRegistrationPublicEntity>;
+    protected localList(args: Args): Promise<QueueRegistrationPublicEntity[]>;
+    protected remoteDelete(bearer: string, args: Args): Promise<void>;
+    protected remoteGet(bearer: string, args: Args): Promise<QueueRegistrationPublicEntity>;
+    protected remoteList(bearer: string, args: Args): Promise<QueueRegistrationPublicEntity[]>;
+    protected remoteUpdate(bearer: string, args: Args, item: QueueRegistrationPublicEntity): Promise<QueueRegistrationPublicEntity>;
+}
+export {};

package/dist/repository/public/registrationPublicRepository.d.ts

@@ -0,0 +1,22 @@
+import { Repository } from "@/repository";
+import { ConferenceRegistrationResponseEntity } from "@/data/conference/Widget";
+import { AuthenticationSecuredService } from "@/service/secured/authenticationSecuredService";
+import { Logger } from "@/utils/logger";
+import { ConferenceRegistrationCancelPublicEntity } from "@/data/conference/RegistrationCancel";
+import { ConferenceRegistrationPublicEntity } from "@/data/conference/Registration";
+export declare class ConferenceRegistrationPublicRepository extends Repository<ConferenceRegistrationResponseEntity, any> {
+    private registrationPublicService;
+    constructor(authenticationService: AuthenticationSecuredService, baseURL: string, logger?: Logger);
+    saveWidgetConferenceRegistration(accountId: string, sessionId: string, data: ConferenceRegistrationPublicEntity): Promise<ConferenceRegistrationResponseEntity>;
+    cancelWidgetConferenceRegistration(accountId: string, data: ConferenceRegistrationCancelPublicEntity): Promise<ConferenceRegistrationResponseEntity>;
+    protected localBulkDelete(items: ConferenceRegistrationResponseEntity[]): Promise<void>;
+    protected localBulkSave(args: any, items: ConferenceRegistrationResponseEntity[]): Promise<void>;
+    protected localDelete(args: any): Promise<void>;
+    protected localGet(args: any): Promise<ConferenceRegistrationResponseEntity>;
+    protected localList(args: any): Promise<ConferenceRegistrationResponseEntity[]>;
+    protected remoteCreate(bearer: string, args: any, item: ConferenceRegistrationResponseEntity): Promise<ConferenceRegistrationResponseEntity>;
+    protected remoteDelete(bearer: string, args: any): Promise<void>;
+    protected remoteGet(bearer: string, args: any): Promise<ConferenceRegistrationResponseEntity>;
+    protected remoteList(bearer: string, args: any): Promise<ConferenceRegistrationResponseEntity[]>;
+    protected remoteUpdate(bearer: string, args: any, item: ConferenceRegistrationResponseEntity): Promise<ConferenceRegistrationResponseEntity>;
+}

package/dist/repository/public/servicePublicRepository.d.ts

@@ -0,0 +1,24 @@
+import { QUERY_RESULT, Repository } from "@/repository";
+import { Logger } from "@/utils/logger";
+import { ServicePublicEntity, ServicesListPublicEntity } from "@/data/Service";
+interface Args {
+    companyId?: string;
+    serviceId?: string;
+}
+export declare class ServicePublicRepository extends Repository<ServicePublicEntity, Args> {
+    private serviceService;
+    constructor(baseURL: string, logger?: Logger);
+    getService(companyId: string, serviceId: string): Promise<QUERY_RESULT<ServicePublicEntity>>;
+    getServiceAndGroups(companyId?: string, accountId?: string, serviceId?: string, serviceGroupId?: string, staffId?: string, staffGroupId?: string, lang?: string, ignoreError?: boolean): Promise<ServicesListPublicEntity>;
+    remoteGet(bearer: string, args: Args): Promise<ServicePublicEntity>;
+    remoteCreate<R>(args: any): Promise<R>;
+    remoteUpdate<R>(args: any): Promise<R>;
+    remoteDelete(args: any): Promise<void>;
+    remoteList(bearer: string, args: Args): Promise<ServicePublicEntity[]>;
+    protected localBulkDelete(items: ServicePublicEntity[]): Promise<void>;
+    protected localBulkSave(args: Args, items: ServicePublicEntity[]): Promise<void>;
+    protected localDelete(args: Args): Promise<void>;
+    protected localGet(args: Args): Promise<ServicePublicEntity>;
+    protected localList(args: Args): Promise<ServicePublicEntity[]>;
+}
+export {};

package/dist/repository/public/sessionPublicRepository.d.ts

@@ -0,0 +1,23 @@
+import { QUERY_RESULTS, Repository } from "@/repository";
+import { ConferenceSessionPublicEntity } from "@/data/conference/Session";
+import { AuthenticationSecuredService } from "@/service/secured/authenticationSecuredService";
+import { Logger } from "@/utils/logger";
+export declare class Args {
+    accountId: string;
+    conferenceId: string;
+}
+export declare class SessionPublicRepository extends Repository<ConferenceSessionPublicEntity, Args> {
+    private sessionPublicService;
+    constructor(authenticationService: AuthenticationSecuredService, baseURL: string, logger?: Logger);
+    getAllConferenceSession(accountId: string, conferenceId: string): Promise<QUERY_RESULTS<ConferenceSessionPublicEntity>>;
+    protected localBulkDelete(items: ConferenceSessionPublicEntity[]): Promise<void>;
+    protected localBulkSave(args: Args, items: ConferenceSessionPublicEntity[]): Promise<void>;
+    protected localDelete(args: Args): Promise<void>;
+    protected localGet(args: Args): Promise<ConferenceSessionPublicEntity>;
+    protected localList(args: Args): Promise<ConferenceSessionPublicEntity[]>;
+    protected remoteCreate(bearer: string, args: Args, item: ConferenceSessionPublicEntity): Promise<ConferenceSessionPublicEntity>;
+    protected remoteDelete(bearer: string, args: Args): Promise<void>;
+    protected remoteGet(bearer: string, args: Args): Promise<ConferenceSessionPublicEntity>;
+    protected remoteList(bearer: string, args: Args): Promise<ConferenceSessionPublicEntity[]>;
+    protected remoteUpdate(bearer: string, args: Args, item: ConferenceSessionPublicEntity): Promise<ConferenceSessionPublicEntity>;
+}

package/dist/repository/public/staffGroupPublicRepository.d.ts

@@ -0,0 +1,24 @@
+import { QUERY_RESULT, Repository } from "@/repository";
+import { StaffGroupPublicEntity } from "@/data/StaffGroup";
+import { Logger } from "@/utils/logger";
+interface Args {
+    staffGroupId?: string;
+    companyId?: string;
+}
+export declare class StaffGroupPublicRepository extends Repository<StaffGroupPublicEntity, Args> {
+    private staffGroupPublicService;
+    constructor(baseURL: string, logger?: Logger);
+    getStaffGroup(companyId: string, staffGroupId: string): Promise<QUERY_RESULT<StaffGroupPublicEntity>>;
+    getStaffGroupsByService(companyId: string, serviceId: string): Promise<StaffGroupPublicEntity[]>;
+    protected remoteGet(bearer: string, args: Args): Promise<StaffGroupPublicEntity>;
+    protected localBulkDelete(items: StaffGroupPublicEntity[]): Promise<void>;
+    protected localBulkSave(args: any, items: StaffGroupPublicEntity[]): Promise<void>;
+    protected localDelete(args: any): Promise<void>;
+    protected localGet(args: any): Promise<StaffGroupPublicEntity>;
+    protected localList(args: any): Promise<StaffGroupPublicEntity[]>;
+    protected remoteCreate(bearer: string, args: any, item: StaffGroupPublicEntity): Promise<StaffGroupPublicEntity>;
+    protected remoteDelete(bearer: string, args: any): Promise<void>;
+    protected remoteList(bearer: string, args: any): Promise<StaffGroupPublicEntity[]>;
+    protected remoteUpdate(bearer: string, args: any, item: StaffGroupPublicEntity): Promise<StaffGroupPublicEntity>;
+}
+export {};

package/dist/repository/public/staffPublicRepository.d.ts

@@ -0,0 +1,24 @@
+import { QUERY_RESULT, Repository } from "@/repository";
+import { StaffPublicEntity } from "@/data/Staff";
+import { Logger } from "@/utils/logger";
+interface Args {
+    staffId?: string;
+    companyId?: string;
+}
+export declare class StaffPublicRepository extends Repository<StaffPublicEntity, Args> {
+    private staffPublicService;
+    constructor(baseURL: string, logger?: Logger);
+    getStaffById(bearer: string, companyId: string, staffId: string): Promise<QUERY_RESULT<StaffPublicEntity>>;
+    getStaffsByService(companyId: string, serviceId: string): Promise<StaffPublicEntity[]>;
+    protected remoteGet(bearer: string, args: Args): Promise<StaffPublicEntity>;
+    protected localBulkDelete(items: StaffPublicEntity[]): Promise<void>;
+    protected localBulkSave(args: any, items: StaffPublicEntity[]): Promise<void>;
+    protected localDelete(args: any): Promise<void>;
+    protected localGet(args: any): Promise<StaffPublicEntity>;
+    protected localList(args: any): Promise<StaffPublicEntity[]>;
+    protected remoteCreate(bearer: string, args: any, item: StaffPublicEntity): Promise<StaffPublicEntity>;
+    protected remoteDelete(bearer: string, args: any): Promise<void>;
+    protected remoteList(bearer: string, args: any): Promise<StaffPublicEntity[]>;
+    protected remoteUpdate(bearer: string, args: any, item: StaffPublicEntity): Promise<StaffPublicEntity>;
+}
+export {};

package/dist/repository/public/widgetPublicRepository.d.ts

@@ -0,0 +1,26 @@
+import { QUERY_RESULT, Repository } from "@/repository";
+import { WidgetEntity } from "@/data/conference/Widget";
+import { AuthenticationSecuredService } from "@/service/secured/authenticationSecuredService";
+import { Logger } from "@/utils/logger";
+export declare class Args {
+    accountId: string;
+    conferenceId: string;
+    sessionId?: string;
+    registrationId?: string;
+    additionalParams: Map<string, string>;
+}
+export declare class WidgetPublicRepository extends Repository<WidgetEntity, Args> {
+    private widgetPublicService;
+    constructor(authenticationService: AuthenticationSecuredService, baseURL: string, logger?: Logger);
+    getWidgetConference(accountId: string, conferenceId: string, additionalQueryParams: Map<string, string>, sessionId?: string, registrationId?: string): Promise<QUERY_RESULT<WidgetEntity>>;
+    protected localBulkDelete(items: WidgetEntity[]): Promise<void>;
+    protected localBulkSave(args: Args, items: WidgetEntity[]): Promise<void>;
+    protected localDelete(args: Args): Promise<void>;
+    protected localGet(args: Args): Promise<WidgetEntity>;
+    protected localList(args: Args): Promise<WidgetEntity[]>;
+    protected remoteCreate(bearer: string, args: Args, item: WidgetEntity): Promise<WidgetEntity>;
+    protected remoteDelete(bearer: string, args: Args): Promise<void>;
+    protected remoteGet(bearer: string, args: Args): Promise<WidgetEntity>;
+    protected remoteList(bearer: string, args: Args): Promise<WidgetEntity[]>;
+    protected remoteUpdate(bearer: string, args: Args, item: WidgetEntity): Promise<WidgetEntity>;
+}

package/dist/repository/secured/CRMSettingsSecuredRepository.d.ts

@@ -0,0 +1,25 @@
+import { QUERY_RESULT, QUERY_TYPE, Repository } from "@/repository";
+import { AuthenticationSecuredService } from "@/service/secured/authenticationSecuredService";
+import { IndexedDb } from "@/db";
+import { Logger } from "@/utils/logger";
+import { CRMSettingsEntity } from "@/data/CRMSettings";
+interface Args {
+    account: string;
+}
+export declare class CRMSettingsSecuredRepository extends Repository<CRMSettingsEntity, Args> {
+    private crmSettingsDb;
+    private crmSettingsSecuredService;
+    constructor(authenticationSecuredService: AuthenticationSecuredService, indexedDb: IndexedDb, baseURL: string, logger?: Logger);
+    getCRMSettings(bearer: string, account: string, mode?: QUERY_TYPE): Promise<QUERY_RESULT<CRMSettingsEntity>>;
+    protected remoteGet(bearer: string, args: Args): Promise<CRMSettingsEntity>;
+    protected remoteList(bearer: string, args: Args): Promise<CRMSettingsEntity[]>;
+    protected remoteCreate(bearer: string, args: Args, item: CRMSettingsEntity): Promise<CRMSettingsEntity>;
+    protected remoteUpdate(bearer: string, args: Args, item: CRMSettingsEntity): Promise<CRMSettingsEntity>;
+    protected remoteDelete(bearer: string, args: Args): Promise<void>;
+    protected localList(args: Args): Promise<CRMSettingsEntity[]>;
+    protected localGet(args: Args): Promise<CRMSettingsEntity>;
+    protected localDelete(args: Args): Promise<void>;
+    protected localBulkSave(args: Args, items: CRMSettingsEntity[]): Promise<void>;
+    protected localBulkDelete(items: CRMSettingsEntity[]): Promise<void>;
+}
+export {};

package/dist/repository/secured/accountSecuredRepository.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Copyright 2022 Agendize All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at.
+ *
+ *      Http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { IndexedDb } from '@/db';
+import { QUERY_RESULT, Repository } from '@/repository';
+import { Logger } from '@/utils/logger';
+import { AuthenticationSecuredService } from "@/service/secured/authenticationSecuredService";
+import { AccountSecuredEntity } from "@/data/Account";
+interface Args {
+    account?: string;
+    crossAccount?: boolean;
+    v2_3?: boolean;
+}
+export declare class AccountSecuredRepository extends Repository<AccountSecuredEntity, Args> {
+    private accountSecuredService;
+    constructor(authenticationSecuredService: AuthenticationSecuredService, indexedDb: IndexedDb, baseURL: string, logger?: Logger);
+    dispose(): void;
+    getAccount(bearer: string, account?: string, crossAccount?: boolean): Promise<QUERY_RESULT<AccountSecuredEntity>>;
+    updateAccount(bearer: string, account: AccountSecuredEntity, v2_3?: boolean): Promise<AccountSecuredEntity>;
+    updatePassword(bearer: string, currentPassword: string, newPassword: string): Promise<void>;
+    protected remoteList(bearer: string, args: Args): Promise<AccountSecuredEntity[]>;
+    protected remoteGet(bearer: string, args: Args): Promise<AccountSecuredEntity>;
+    protected remoteCreate(bearer: string, args: Args, item: AccountSecuredEntity): Promise<AccountSecuredEntity>;
+    protected remoteUpdate(bearer: string, args: Args, item: AccountSecuredEntity): Promise<AccountSecuredEntity>;
+    protected remoteDelete(bearer: string, args: Args): Promise<void>;
+    protected localList(args: Args): Promise<AccountSecuredEntity[]>;
+    protected localGet(args: Args): Promise<AccountSecuredEntity>;
+    protected localBulkSave(args: Args, staffs: AccountSecuredEntity[]): Promise<void>;
+    protected localDelete(args: Args): Promise<void>;
+    protected localBulkDelete(items: AccountSecuredEntity[]): Promise<void>;
+}
+export {};

package/dist/repository/secured/activitySecuredRepository.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Copyright 2022 Agendize All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at.
+ *
+ *      Http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { IndexedDb } from '@/db';
+import { QUERY_RESULTS, Repository } from '@/repository';
+import { Logger } from '@/utils/logger';
+import { AuthenticationSecuredService } from "@/service/secured/authenticationSecuredService";
+import { ActivityEntity } from "@/data/Activity";
+interface Args {
+    account: string;
+    clientId?: string;
+    eventId?: string;
+}
+export declare class ActivitySecuredRepository extends Repository<ActivityEntity, Args> {
+    private activitySecuredService;
+    constructor(authenticationSecuredService: AuthenticationSecuredService, indexedDb: IndexedDb, baseURL: string, logger?: Logger);
+    getAllActivities(bearer: string, account: string, clientId: string): Promise<QUERY_RESULTS<ActivityEntity>>;
+    getAllEventActivities(bearer: string, account: string, clientId: string, eventId: string): Promise<QUERY_RESULTS<ActivityEntity>>;
+    protected remoteList(bearer: string, args: Args): Promise<ActivityEntity[]>;
+    protected remoteGet(bearer: string, args: Args): Promise<ActivityEntity>;
+    protected remoteCreate(bearer: string, args: Args, item: ActivityEntity): Promise<ActivityEntity>;
+    protected remoteUpdate(bearer: string, args: Args, item: ActivityEntity): Promise<ActivityEntity>;
+    protected remoteDelete(bearer: string, args: Args): Promise<void>;
+    protected localList(args: Args): Promise<ActivityEntity[]>;
+    protected localGet(args: Args): Promise<ActivityEntity>;
+    protected localBulkSave(args: Args, activities: ActivityEntity[]): Promise<void>;
+    protected localDelete(args: Args): Promise<void>;
+    protected localBulkDelete(items: ActivityEntity[]): Promise<void>;
+    private checkNullable;
+}
+export {};