@dev-crew-berlin/enter-js-utils 0.70.2 → 0.72.0

package/dist/api-client/api-base.d.ts

@@ -17,6 +17,12 @@ declare type ResponseType<Path extends keyof paths, Method extends HTTPMethod> =
 export declare type RequestBody<Path extends keyof paths, Method extends HTTPMethod> = paths[Path] extends Record<Method, {
     requestBody: JSONRes;
 }> ? paths[Path][Method]['requestBody']['content']['application/json'] : never;
+export declare type FetchOptions = {
+    cache?: 'force-cache' | 'no-store';
+    next?: {
+        revalidate: false | 0 | number;
+    };
+};
 export default class APIBase {
     private credentials;
     private isLoggedIn;
@@ -45,11 +51,11 @@ export default class APIBase {
         expires: Date;
     }>>;
     private fetchFromEnter;
-    protected get<Path extends keyof paths>(endpoint: Path): Promise<APIResult<ResponseType<Path, 'get'>>>;
-    protected post<Path extends keyof paths>(endpoint: Path, data: RequestBody<Path, 'post'>): Promise<APIResult<ResponseType<Path, 'post'>>>;
-    protected put<Path extends keyof paths>(endpoint: Path, data: RequestBody<Path, 'put'>): Promise<APIResult<ResponseType<Path, 'put'>>>;
-    protected patch<Path extends keyof paths>(endpoint: Path, data: RequestBody<Path, 'patch'>): Promise<APIResult<ResponseType<Path, 'patch'>>>;
-    protected delete<Path extends keyof paths>(endpoint: Path): Promise<APIResult<ResponseType<Path, 'delete'>>>;
+    protected get<Path extends keyof paths>(endpoint: Path, options: FetchOptions): Promise<APIResult<ResponseType<Path, 'get'>>>;
+    protected post<Path extends keyof paths>(endpoint: Path, data: RequestBody<Path, 'post'>, options: FetchOptions): Promise<APIResult<ResponseType<Path, 'post'>>>;
+    protected put<Path extends keyof paths>(endpoint: Path, data: RequestBody<Path, 'put'>, options: FetchOptions): Promise<APIResult<ResponseType<Path, 'put'>>>;
+    protected patch<Path extends keyof paths>(endpoint: Path, data: RequestBody<Path, 'patch'>, options: FetchOptions): Promise<APIResult<ResponseType<Path, 'patch'>>>;
+    protected delete<Path extends keyof paths>(endpoint: Path, options: FetchOptions): Promise<APIResult<ResponseType<Path, 'delete'>>>;
     logout(): Promise<void>;
 }
 export {};

package/dist/api-client/api-base.js

@@ -68,7 +68,7 @@ export default class APIBase {
       return failure(`${error}`);
     }
   }
-  async fetchFromEnter(endpoint, method, data) {
+  async fetchFromEnter(endpoint, method, data, options) {
     const body = data !== null ? JSON.stringify(data) : null;
     const headers = {
       Authorization: `bearer ${this.credentials.accessToken}`,
@@ -79,7 +79,8 @@ export default class APIBase {
     const res = await APIBase.fetchResult(`${this.credentials.url}${endpoint}`, {
       method: method.toUpperCase(),
       headers,
-      body
+      body,
+      ...options
     });
     if (!res.success) {
       return failure([{
@@ -121,28 +122,28 @@ export default class APIBase {
     const json = await res.data.json();
     return success(json);
   }
-  async get(endpoint) {
-    const rawResponse = await this.fetchFromEnter(endpoint, 'get', undefined);
+  async get(endpoint, options) {
+    const rawResponse = await this.fetchFromEnter(endpoint, 'get', undefined, options);
     if (!rawResponse.success) return rawResponse;
     return success(rawResponse.data);
   }
-  async post(endpoint, data) {
-    const rawResponse = await this.fetchFromEnter(endpoint, 'post', data);
+  async post(endpoint, data, options) {
+    const rawResponse = await this.fetchFromEnter(endpoint, 'post', data, options);
     if (!rawResponse.success) return rawResponse;
     return success(rawResponse.data);
   }
-  async put(endpoint, data) {
-    const rawResponse = await this.fetchFromEnter(endpoint, 'put', data);
+  async put(endpoint, data, options) {
+    const rawResponse = await this.fetchFromEnter(endpoint, 'put', data, options);
     if (!rawResponse.success) return rawResponse;
     return success(rawResponse.data);
   }
-  async patch(endpoint, data) {
-    const rawResponse = await this.fetchFromEnter(endpoint, 'patch', data);
+  async patch(endpoint, data, options) {
+    const rawResponse = await this.fetchFromEnter(endpoint, 'patch', data, options);
     if (!rawResponse.success) return rawResponse;
     return success(rawResponse.data);
   }
-  async delete(endpoint) {
-    const rawResponse = await this.fetchFromEnter(endpoint, 'delete', undefined);
+  async delete(endpoint, options) {
+    const rawResponse = await this.fetchFromEnter(endpoint, 'delete', undefined, options);
     if (!rawResponse.success) return rawResponse;
     return success(rawResponse.data);
   }

package/dist/api-client/index.d.ts

@@ -1,4 +1,4 @@
-import APIBase, { RequestBody } from './api-base';
+import APIBase, { FetchOptions, RequestBody } from './api-base';
 import { APIResult } from '../lib';
 import { Attendee } from '../models/attendee';
 import { Event } from '../models';
@@ -11,72 +11,72 @@ import { components } from '../generated/api-schema';
 import { Email } from '../models/email';
 export type { APICredentials } from './api-base';
 export default class API extends APIBase {
-    getInstanceList(): Promise<APIResult<Instance[]>>;
+    getInstanceList(options?: FetchOptions): Promise<APIResult<Instance[]>>;
     getInstance(args: {
         instanceName: string;
-    }): Promise<APIResult<Instance>>;
+    }, options?: FetchOptions): Promise<APIResult<Instance>>;
     getFields(args: {
         instanceName: string;
-    }): Promise<APIResult<FieldGroups>>;
+    }, options?: FetchOptions): Promise<APIResult<FieldGroups>>;
     getCheckinCounts(args: {
         instanceName: string;
-    }): Promise<APIResult<CheckinCounts>>;
+    }, options?: FetchOptions): Promise<APIResult<CheckinCounts>>;
     calculateCustomCounts(args: {
         instanceName: string;
         counter: components['schemas']['CustomCounter'][];
-    }): Promise<APIResult<{
+    }, options?: FetchOptions): Promise<APIResult<{
         [key: string]: number;
     }>>;
     getAttendeeList(args: {
         instanceName: string;
         filter?: string;
         includeDeleted?: boolean;
-    }): Promise<APIResult<Attendee[]>>;
+    }, options?: FetchOptions): Promise<APIResult<Attendee[]>>;
     getAttendee(args: {
         instanceName: string;
         attendeeId: string;
         includeDeleted?: boolean;
-    }): Promise<APIResult<Attendee>>;
+    }, options?: FetchOptions): Promise<APIResult<Attendee>>;
     getCompanions(args: {
         instanceName: string;
         attendeeId: string;
         includeDeleted?: boolean;
-    }): Promise<APIResult<Attendee[]>>;
+    }, options?: FetchOptions): Promise<APIResult<Attendee[]>>;
     generateRegistrationToken(args: {
         instanceName: string;
         check: components['schemas']['SecurityQuestion'] | components['schemas']['AuthCode'] | components['schemas']['AttendeeId'];
-    }): Promise<APIResult<string>>;
+    }, options?: FetchOptions): Promise<APIResult<string>>;
     getVariableList(args: {
         instanceName: string;
-    }): Promise<APIResult<Variable[]>>;
+    }, options?: FetchOptions): Promise<APIResult<Variable[]>>;
     getVariable(args: {
         instanceName: string;
         variableName: string;
-    }): Promise<APIResult<Variable>>;
+    }, options?: FetchOptions): Promise<APIResult<Variable>>;
     createVariable(args: {
         instanceName: string;
         variable: Variable;
-    }): Promise<APIResult<Variable>>;
+    }, options?: FetchOptions): Promise<APIResult<Variable>>;
     updateVariable(args: {
         instanceName: string;
         variableName: string;
         update: RequestBody<'/instances/{instance_name}/variables/{variable_name}', 'put'>;
-    }): Promise<APIResult<Variable>>;
+    }, options?: FetchOptions): Promise<APIResult<Variable>>;
     deleteVariable(args: {
         instanceName: string;
         variableName: string;
-    }): Promise<APIResult<null>>;
-    getUser(): Promise<APIResult<User>>;
-    updateUser(args: RequestBody<'/users/me', 'patch'>): Promise<APIResult<User>>;
+    }, options?: FetchOptions): Promise<APIResult<null>>;
+    getUser(options?: FetchOptions): Promise<APIResult<User>>;
+    updateUser(args: RequestBody<'/users/me', 'patch'>, options?: FetchOptions): Promise<APIResult<User>>;
     sendEmail(args: {
         instanceName: string;
         attendeeId: string;
         emailName: string;
-    }): Promise<APIResult<null>>;
+    }, options?: FetchOptions): Promise<APIResult<null>>;
     getRenderedEmail(args: {
         instanceName: string;
         attendeeId: string;
         emailName: string;
-    }): Promise<APIResult<Email>>;
-    createEvents(args: Event[]): Promise<APIResult<null>>;
+    }, options?: FetchOptions): Promise<APIResult<Email>>;
+    createEvents(args: Event[], options?: FetchOptions): Promise<APIResult<null>>;
 }

package/dist/api-client/index.js

@@ -4,34 +4,34 @@ import { Attendee } from '../models/attendee';
 import { FieldGroups } from '../models/field-group';
 import { Instance } from '../models/instance';
 export default class API extends APIBase {
-  async getInstanceList() {
-    const result = await this.get('/instances');
+  async getInstanceList(options = {}) {
+    const result = await this.get('/instances', options);
     if (!result.success) return result;
     return success(result.data.map(instanceJSON => new Instance(instanceJSON)));
   }
-  async getInstance(args) {
+  async getInstance(args, options = {}) {
     const instanceName = args.instanceName;
-    const result = await this.get(`/instances/${instanceName}`);
+    const result = await this.get(`/instances/${instanceName}`, options);
     if (!result.success) return result;
     return success(new Instance(result.data));
   }
-  async getFields(args) {
+  async getFields(args, options = {}) {
     const instanceName = args.instanceName;
-    const result = await this.get(`/instances/${instanceName}/fields`);
+    const result = await this.get(`/instances/${instanceName}/fields`, options);
     if (!result.success) return result;
     return success(new FieldGroups(result.data));
   }
-  async getCheckinCounts(args) {
+  async getCheckinCounts(args, options = {}) {
     const instanceName = args.instanceName;
-    return this.get(`/instances/${instanceName}/checkin_counts`);
+    return this.get(`/instances/${instanceName}/checkin_counts`, options);
   }
-  async calculateCustomCounts(args) {
+  async calculateCustomCounts(args, options = {}) {
     const instanceName = args.instanceName;
     return this.post(`/instances/${instanceName}/custom_counts`, {
       counters: args.counter
-    });
+    }, options);
   }
-  async getAttendeeList(args) {
+  async getAttendeeList(args, options = {}) {
     const query = new URLSearchParams();
     if (args.filter) {
       query.append('filter', args.filter);
@@ -41,11 +41,11 @@ export default class API extends APIBase {
     }
     const instanceName = args.instanceName;
     const queryString = `?${query.toString()}`;
-    const result = await this.get(`/instances/${instanceName}/attendees${queryString}`);
+    const result = await this.get(`/instances/${instanceName}/attendees${queryString}`, options);
     if (!result.success) return result;
     return success(result.data.map(attendeeJSON => new Attendee(attendeeJSON)));
   }
-  async getAttendee(args) {
+  async getAttendee(args, options = {}) {
     const query = new URLSearchParams();
     if (args.includeDeleted) {
       query.append('include_deleted', 'true');
@@ -53,11 +53,11 @@ export default class API extends APIBase {
     const instanceName = args.instanceName;
     const attendeeId = args.attendeeId;
     const queryString = `?${query.toString()}`;
-    const result = await this.get(`/instances/${instanceName}/attendees/${attendeeId}${queryString}`);
+    const result = await this.get(`/instances/${instanceName}/attendees/${attendeeId}${queryString}`, options);
     if (!result.success) return result;
     return success(new Attendee(result.data));
   }
-  async getCompanions(args) {
+  async getCompanions(args, options = {}) {
     const query = new URLSearchParams();
     if (args.includeDeleted) {
       query.append('include_deleted', 'true');
@@ -65,56 +65,56 @@ export default class API extends APIBase {
     const instanceName = args.instanceName;
     const attendeeId = args.attendeeId;
     const queryString = `?${query.toString()}`;
-    const result = await this.get(`/instances/${instanceName}/attendees/${attendeeId}/companions${queryString}`);
+    const result = await this.get(`/instances/${instanceName}/attendees/${attendeeId}/companions${queryString}`, options);
     if (!result.success) return result;
     return success(result.data.map(attendeeJSON => new Attendee(attendeeJSON)));
   }
-  async generateRegistrationToken(args) {
+  async generateRegistrationToken(args, options = {}) {
     const instanceName = args.instanceName;
-    return this.post(`/instances/${instanceName}/registration/registration_token`, args.check);
+    return this.post(`/instances/${instanceName}/registration/registration_token`, args.check, options);
   }
-  async getVariableList(args) {
+  async getVariableList(args, options = {}) {
     const instanceName = args.instanceName;
-    return this.get(`/instances/${instanceName}/variables`);
+    return this.get(`/instances/${instanceName}/variables`, options);
   }
-  async getVariable(args) {
+  async getVariable(args, options = {}) {
     const instanceName = args.instanceName;
     const variableName = args.variableName;
-    return this.get(`/instances/${instanceName}/variables/${variableName}`);
+    return this.get(`/instances/${instanceName}/variables/${variableName}`, options);
   }
-  async createVariable(args) {
+  async createVariable(args, options = {}) {
     const instanceName = args.instanceName;
-    return this.post(`/instances/${instanceName}/variables`, args.variable);
+    return this.post(`/instances/${instanceName}/variables`, args.variable, options);
   }
-  async updateVariable(args) {
+  async updateVariable(args, options = {}) {
     const instanceName = args.instanceName;
     const variableName = args.variableName;
-    return this.put(`/instances/${instanceName}/variables/${variableName}`, args.update);
+    return this.put(`/instances/${instanceName}/variables/${variableName}`, args.update, options);
   }
-  async deleteVariable(args) {
+  async deleteVariable(args, options = {}) {
     const instanceName = args.instanceName;
     const variableName = args.variableName;
-    return this.delete(`/instances/${instanceName}/variables/${variableName}`);
+    return this.delete(`/instances/${instanceName}/variables/${variableName}`, options);
   }
-  async getUser() {
-    return this.get('/users/me');
+  async getUser(options = {}) {
+    return this.get('/users/me', options);
   }
-  async updateUser(args) {
-    return this.patch('/users/me', args);
+  async updateUser(args, options = {}) {
+    return this.patch('/users/me', args, options);
   }
-  async sendEmail(args) {
+  async sendEmail(args, options = {}) {
     const instanceName = args.instanceName;
     const attendeeId = args.attendeeId;
     const emailName = args.emailName;
-    return this.post(`/instances/${instanceName}/attendees/${attendeeId}/emails/${emailName}/send`, null);
+    return this.post(`/instances/${instanceName}/attendees/${attendeeId}/emails/${emailName}/send`, null, options);
   }
-  async getRenderedEmail(args) {
+  async getRenderedEmail(args, options = {}) {
     const instanceName = args.instanceName;
     const attendeeId = args.attendeeId;
     const emailName = args.emailName;
-    return this.get(`/instances/${instanceName}/attendees/${attendeeId}/emails/${emailName}/render`);
+    return this.get(`/instances/${instanceName}/attendees/${attendeeId}/emails/${emailName}/render`, options);
   }
-  async createEvents(args) {
-    return this.post(`/events`, args);
+  async createEvents(args, options = {}) {
+    return this.post(`/events`, args, options);
   }
 }

package/dist/generated/api-schema.d.ts

@@ -1239,6 +1239,76 @@ export declare type components = {
              */
             max: number;
         };
+        /** EmailStatus */
+        EmailStatus: {
+            /**
+             * Mailing Id
+             * @description the unique id of the bulk or single mailing
+             */
+            mailing_id: string;
+            /**
+             * Status
+             * @enum {string}
+             */
+            status: "pending" | "waiting" | "submitted" | "skipped" | "sent" | "opened" | "clicked" | "invalid" | "rejected" | "unsubscribed";
+            /**
+             * Updated At
+             * Format: date-time
+             */
+            updated_at?: string;
+            /**
+             * Time
+             * @description the time the email was sent (this should only be set when setting the status to 'sent')
+             */
+            time?: string | null;
+            /**
+             * Reason
+             * @description for error states a reason can be added to the event (reasons will be merged with reasons from prevoius errors)
+             */
+            reason?: string | string[];
+            /**
+             * Clients
+             * @description for open events a set of email clients can be added (those will be merged with clients from prevois states)
+             */
+            clients?: string[];
+            /**
+             * Clicks
+             * @description for clicked events a url can be provided (those will be merged with clicks from prevois events)
+             */
+            clicks?: string[];
+        };
+        /**
+         * EmailStatusUpdatedEvent
+         * @description EmailStatus for attendee was updated.
+         *
+         * Note that there is a special email-unsubscribed-event that also
+         * adds the email address to a blacklist.
+         * This event will only update the email status of the atttendee and nothing else.
+         */
+        EmailStatusUpdatedEvent: {
+            /**
+             * Id
+             * Format: uuid
+             */
+            id?: string;
+            /**
+             * Event
+             * @default email-status-updated
+             * @constant
+             * @enum {string}
+             */
+            event?: "email-status-updated";
+            /** Group */
+            group?: components["schemas"]["EventGroup"] | components["schemas"]["NoGroup"];
+            preconditions?: components["schemas"]["Filter"] | null;
+            /** Instancename */
+            instanceName: string;
+            /** Attendeeid */
+            attendeeId: string;
+            /** Mailid */
+            mailId: string;
+            emailStatus: components["schemas"]["EmailStatus"];
+        };
         /**
          * EmailUnsubscribedEvent
          * @description Attendee unsubscribed from email list.
@@ -2289,8 +2359,8 @@ export declare type components = {
         "RootModel_Union_Companion__MainGuest__-Input": components["schemas"]["Companion-Input"] | components["schemas"]["MainGuest-Input"];
         /** RootModel[Union[Companion, MainGuest]] */
         "RootModel_Union_Companion__MainGuest__-Output": components["schemas"]["Companion-Output"] | components["schemas"]["MainGuest-Output"];
-        /** RootModel[list[Annotated[Union[AttendeeCreatedEvent, AttendeeUpdatedEvent, AttendeeRespondedEvent, AttendeeAuthCodeRequested, EmailUnsubscribedEvent, AttendeeDeletedEvent, CheckinCreatedEvent, CheckinDeletedEvent, PaymentPaidEvent], FieldInfo(annotation=NoneType, required=True, discriminator='event')]]] */
-        RootModel_list_Annotated_Union_AttendeeCreatedEvent__AttendeeUpdatedEvent__AttendeeRespondedEvent__AttendeeAuthCodeRequested__EmailUnsubscribedEvent__AttendeeDeletedEvent__CheckinCreatedEvent__CheckinDeletedEvent__PaymentPaidEvent___FieldInfo_annotation_NoneType__required_True__discriminator__event_____: (components["schemas"]["AttendeeCreatedEvent"] | components["schemas"]["AttendeeUpdatedEvent"] | components["schemas"]["AttendeeRespondedEvent"] | components["schemas"]["AttendeeAuthCodeRequested"] | components["schemas"]["EmailUnsubscribedEvent"] | components["schemas"]["AttendeeDeletedEvent"] | components["schemas"]["CheckinCreatedEvent"] | components["schemas"]["CheckinDeletedEvent"] | components["schemas"]["PaymentPaidEvent"])[];
+        /** RootModel[list[Annotated[Union[AttendeeCreatedEvent, AttendeeUpdatedEvent, AttendeeRespondedEvent, AttendeeAuthCodeRequested, EmailStatusUpdatedEvent, EmailUnsubscribedEvent, AttendeeDeletedEvent, CheckinCreatedEvent, CheckinDeletedEvent, PaymentPaidEvent], FieldInfo(annotation=NoneType, required=True, discriminator='event')]]] */
+        RootModel_list_Annotated_Union_AttendeeCreatedEvent__AttendeeUpdatedEvent__AttendeeRespondedEvent__AttendeeAuthCodeRequested__EmailStatusUpdatedEvent__EmailUnsubscribedEvent__AttendeeDeletedEvent__CheckinCreatedEvent__CheckinDeletedEvent__PaymentPaidEvent___FieldInfo_annotation_NoneType__required_True__discriminator__event_____: (components["schemas"]["AttendeeCreatedEvent"] | components["schemas"]["AttendeeUpdatedEvent"] | components["schemas"]["AttendeeRespondedEvent"] | components["schemas"]["AttendeeAuthCodeRequested"] | components["schemas"]["EmailStatusUpdatedEvent"] | components["schemas"]["EmailUnsubscribedEvent"] | components["schemas"]["AttendeeDeletedEvent"] | components["schemas"]["CheckinCreatedEvent"] | components["schemas"]["CheckinDeletedEvent"] | components["schemas"]["PaymentPaidEvent"])[];
         /** SecurityQuestion */
         SecurityQuestion: {
             security_question: components["schemas"]["QuestionFields"];
@@ -2726,7 +2796,7 @@ export declare type operations = {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["RootModel_list_Annotated_Union_AttendeeCreatedEvent__AttendeeUpdatedEvent__AttendeeRespondedEvent__AttendeeAuthCodeRequested__EmailUnsubscribedEvent__AttendeeDeletedEvent__CheckinCreatedEvent__CheckinDeletedEvent__PaymentPaidEvent___FieldInfo_annotation_NoneType__required_True__discriminator__event_____"];
+                "application/json": components["schemas"]["RootModel_list_Annotated_Union_AttendeeCreatedEvent__AttendeeUpdatedEvent__AttendeeRespondedEvent__AttendeeAuthCodeRequested__EmailStatusUpdatedEvent__EmailUnsubscribedEvent__AttendeeDeletedEvent__CheckinCreatedEvent__CheckinDeletedEvent__PaymentPaidEvent___FieldInfo_annotation_NoneType__required_True__discriminator__event_____"];
             };
         };
         responses: {

package/dist/models/event.d.ts

@@ -8,4 +8,4 @@ export declare type EmailUnsubscribedEvent = components['schemas']['EmailUnsubsc
 export declare type CheckinCreatedEvent = components['schemas']['CheckinCreatedEvent'];
 export declare type CheckinDeletedEvent = components['schemas']['CheckinDeletedEvent'];
 export declare type PaymentPaidEvent = components['schemas']['PaymentPaidEvent'];
-export declare type Event = components['schemas']['RootModel_list_Annotated_Union_AttendeeCreatedEvent__AttendeeUpdatedEvent__AttendeeRespondedEvent__AttendeeAuthCodeRequested__EmailUnsubscribedEvent__AttendeeDeletedEvent__CheckinCreatedEvent__CheckinDeletedEvent__PaymentPaidEvent___FieldInfo_annotation_NoneType__required_True__discriminator__event_____'][number];
+export declare type Event = components['schemas']['RootModel_list_Annotated_Union_AttendeeCreatedEvent__AttendeeUpdatedEvent__AttendeeRespondedEvent__AttendeeAuthCodeRequested__EmailStatusUpdatedEvent__EmailUnsubscribedEvent__AttendeeDeletedEvent__CheckinCreatedEvent__CheckinDeletedEvent__PaymentPaidEvent___FieldInfo_annotation_NoneType__required_True__discriminator__event_____'][number];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dev-crew-berlin/enter-js-utils",
-  "version": "0.70.2",
+  "version": "0.72.0",
   "description": "utils such as vaildation and other helpers to work with data from the enter app",
   "files": [
     "dist",