@syzy/apphost 1.0.1 → 1.0.3

package/dist/store/HostedInContainerContext.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from 'react';
+const HostedInContainerContext = createContext(false);
+export const HostedInContainerProvider = ({ children }) => {
+    const isHosted = (() => {
+        const urlParams = new URLSearchParams(window.location.search);
+        return urlParams.get('hosted_in_container') === 'true';
+    })();
+    return (_jsx(HostedInContainerContext.Provider, { value: isHosted, children: children }));
+};
+export const useHostedInContainer = () => useContext(HostedInContainerContext);

package/dist/store/SesssionReducer.d.ts

@@ -0,0 +1,4 @@
+import { Reducer, Dispatch } from 'react';
+import { AppSession } from './AppContextType';
+export declare const APPHOSTSESSION_KEY = "AppHostSession";
+export declare const useSessionReducer: <T extends AppSession, A>(reducer: Reducer<T, A>, initialState: T, storageKey: string) => [T, Dispatch<A>];

package/dist/store/SesssionReducer.js

@@ -0,0 +1,16 @@
+import { useReducer, useEffect } from 'react';
+export const APPHOSTSESSION_KEY = 'AppHostSession';
+export const useSessionReducer = (reducer, initialState, storageKey) => {
+    const [state, dispatch] = useReducer(reducer, initialState, () => {
+        const value = localStorage.getItem(storageKey); // use storageKey here
+        let retState = { ...initialState };
+        if (value) {
+            retState = JSON.parse(value);
+        }
+        return retState;
+    });
+    useEffect(() => {
+        localStorage.setItem(storageKey, JSON.stringify(state)); // same key
+    }, [storageKey, state]);
+    return [state, dispatch];
+};

package/dist/types.d.ts

@@ -0,0 +1,26 @@
+export interface Route {
+    path: string;
+    component: React.ComponentType<any>;
+    title: string;
+    requiredComponent?: string;
+    exact?: boolean;
+    acl?: {
+        [key in Role]: {
+            type: DecisionType;
+            meta?: string;
+        };
+    };
+    props?: any;
+}
+export declare enum Role {
+    GUEST = "GUEST",
+    MEMBER = "MEMBER",
+    CHAPTERADMIN = "CHAPTERADMIN",
+    SUPPORTADMIN = "SUPPORTADMIN",
+    SUPERADMIN = "SUPERADMIN"
+}
+export declare enum DecisionType {
+    ALLOW = "allow",
+    DENY = "deny",
+    REDIRECT = "redirect"
+}

package/dist/types.js

@@ -0,0 +1,14 @@
+export var Role;
+(function (Role) {
+    Role["GUEST"] = "GUEST";
+    Role["MEMBER"] = "MEMBER";
+    Role["CHAPTERADMIN"] = "CHAPTERADMIN";
+    Role["SUPPORTADMIN"] = "SUPPORTADMIN";
+    Role["SUPERADMIN"] = "SUPERADMIN";
+})(Role || (Role = {}));
+export var DecisionType;
+(function (DecisionType) {
+    DecisionType["ALLOW"] = "allow";
+    DecisionType["DENY"] = "deny";
+    DecisionType["REDIRECT"] = "redirect";
+})(DecisionType || (DecisionType = {}));

package/dist/util/AuthUtils.d.ts

@@ -0,0 +1 @@
+export declare function isSignedIn(): Promise<boolean>;

package/dist/util/AuthUtils.js

@@ -0,0 +1,10 @@
+import { getCurrentUser } from "aws-amplify/auth";
+export async function isSignedIn() {
+    try {
+        const session = await getCurrentUser();
+        return session !== null && session !== undefined && session.userId !== undefined;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/util/LogEnum.d.ts

@@ -0,0 +1,6 @@
+export declare enum LogCategoryEnum {
+    Info = "info",
+    Warning = "warning",
+    Error = "error",
+    Warn = "Warn"
+}

package/dist/util/LogEnum.js

@@ -0,0 +1,7 @@
+export var LogCategoryEnum;
+(function (LogCategoryEnum) {
+    LogCategoryEnum["Info"] = "info";
+    LogCategoryEnum["Warning"] = "warning";
+    LogCategoryEnum["Error"] = "error";
+    LogCategoryEnum["Warn"] = "Warn";
+})(LogCategoryEnum || (LogCategoryEnum = {}));

package/dist/util/Logger.d.ts

@@ -0,0 +1,6 @@
+export declare const logger: {
+    debug: (...args: any[]) => false | void;
+    info: (...args: any[]) => false | void;
+    warn: (...args: any[]) => false | void;
+    error: (...args: any[]) => false | void;
+};

package/dist/util/Logger.js

@@ -0,0 +1,18 @@
+const levels = {
+    debug: 1,
+    info: 2,
+    warn: 3,
+    error: 4,
+    none: 5,
+};
+// Current log level (from env)
+const currentLevel = (import.meta.env.VITE_LOG_LEVEL || 'info');
+function shouldLog(level) {
+    return levels[level] >= levels[currentLevel];
+}
+export const logger = {
+    debug: (...args) => shouldLog('debug') && console.debug('[DEBUG]', ...args),
+    info: (...args) => shouldLog('info') && console.info('[INFO]', ...args),
+    warn: (...args) => shouldLog('warn') && console.warn('[WARN]', ...args),
+    error: (...args) => shouldLog('error') && console.error('[ERROR]', ...args),
+};

package/dist/util/SyzyDate.d.ts

@@ -0,0 +1,69 @@
+export declare class SyzyDate extends Date {
+    static months: string[];
+    addDays: (days: number) => Date;
+    reduceDays: (days: number) => Date;
+    isSameDate: (date: Date) => boolean;
+    isToday: () => boolean;
+    clone: () => Date;
+    isAnotherMonth: (date: Date) => boolean;
+    isWeekend: () => boolean;
+    toISODate: () => string;
+    /**
+     *
+     * @returns Current Date as ISO string with T between date and time
+     */
+    toISODateTime: () => string;
+    toISODateString(): string;
+    /***
+     * To Given Format
+     * DD- Date
+     * MM- Month in 2 digits
+     * Mon- Month in 3 letters
+     * mm- Minutes
+     * HH- Hours in 24 hour format
+     * hh- Hours in 12 hour format
+     * ss- Seconds
+     * YYYY- Year in 4 digits
+     * YY- Year in 2 digits
+     */
+    toDateFormatString(format: string): string;
+    getCurrentISODate: () => string;
+    toDate: () => Date;
+    getCurrentDate: () => SyzyDate;
+    currentWeek: () => number;
+    currentTerm: () => number;
+    currentQuarter: () => number;
+    getCurrentYrAndMonAndQuarterAndTerm: () => {
+        currentYr: number;
+        currentMon: number;
+        currTerm: number;
+        currentQuarter: number;
+    };
+    getWeekNo: () => number;
+    getcurrentTerm: () => number;
+    getCurrentQuarter: () => number;
+    getCurrentMonthStartAndEnd: () => {
+        startOfMonth: Date;
+        endOfMonth: Date;
+    };
+    getCurrentTermStartAndEnd: () => {
+        startOfTerm: Date;
+        endDateOfTerm: Date;
+    };
+    getCurrentYearStartAndEnd: () => {
+        startOfYear: Date;
+        endOfYear: Date;
+    };
+    getCurrentQuarterStartAndEnd: () => {
+        startDateOfQuarter: Date;
+        endDateOfQuarter: Date;
+    };
+    getCurrentWeekStartAndEnd: () => {
+        startDateOfWeek: Date;
+        endDateOfWeek: Date;
+    };
+    getSelectedMonthStartAndEnd: (month: number) => {
+        startOfSelectedMonth: Date;
+        endOfSelectedMonth: Date;
+    };
+}

package/dist/util/SyzyDate.js

@@ -0,0 +1,265 @@
+import { DATE_FORMAT_ISO_YYYY_MM_DD } from "./dateUtils";
+export class SyzyDate extends Date {
+    static months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+    addDays = (days) => {
+        if (!days)
+            return this;
+        this.setDate(this.getDate() + days);
+        return this;
+    };
+    reduceDays = (days) => {
+        if (!days)
+            return this;
+        this.setDate(this.getDate() - days);
+        return this;
+    };
+    isSameDate = (date) => {
+        return date && this.getFullYear() === date.getFullYear() && this.getMonth() === date.getMonth() && this.getDate() === date.getDate();
+    };
+    isToday = () => {
+        const today = new Date();
+        return this.isSameDate(today);
+    };
+    clone = () => {
+        return new Date(+this);
+    };
+    isAnotherMonth = (date) => {
+        return date && this.getMonth() !== date.getMonth();
+    };
+    isWeekend = () => {
+        return this.getDay() === 0 || this.getDay() === 6;
+    };
+    toISODate = () => {
+        return this.toISOString().split('T')[0];
+    };
+    /**
+     *
+     * @returns Current Date as ISO string with T between date and time
+     */
+    toISODateTime = () => {
+        let dt = this.toISOString();
+        dt = dt.replace('T', ' ');
+        dt = dt.substring(0, dt.indexOf('.'));
+        return dt;
+    };
+    toISODateString() {
+        return this.toDateFormatString(DATE_FORMAT_ISO_YYYY_MM_DD);
+    }
+    /***
+     * To Given Format
+     * DD- Date
+     * MM- Month in 2 digits
+     * Mon- Month in 3 letters
+     * mm- Minutes
+     * HH- Hours in 24 hour format
+     * hh- Hours in 12 hour format
+     * ss- Seconds
+     * YYYY- Year in 4 digits
+     * YY- Year in 2 digits
+     */
+    toDateFormatString(format) {
+        let formatString = format;
+        // HH - 24 hour format
+        if (formatString.includes("HH")) {
+            formatString = formatString.replace("HH", this.getHours().toString().padStart(2, '0'));
+        }
+        if (formatString.includes("mm")) {
+            formatString = formatString.replace("mm", this.getMinutes().toString().padStart(2, '0'));
+        }
+        if (formatString.includes("ss")) {
+            formatString = formatString.replace("ss", this.getSeconds().toString().padStart(2, '0'));
+        }
+        if (formatString.includes("DD")) {
+            formatString = formatString.replace("DD", this.getDate().toString().padStart(2, '0'));
+        }
+        if (formatString.includes("MM")) {
+            formatString = formatString.replace("MM", (this.getMonth() + 1).toString().padStart(2, '0'));
+        }
+        if (formatString.includes("YYYY")) {
+            formatString = formatString.replace("YYYY", this.getFullYear().toString().padStart(2, '0'));
+        }
+        if (formatString.includes("YY")) {
+            formatString = formatString.replace("YY", this.getFullYear().toString().substring(2));
+        }
+        if (formatString.includes("Mon")) {
+            formatString = formatString.replace("Mon", SyzyDate.months[this.getMonth()]);
+        }
+        // hh will have am/pm
+        if (formatString.includes("hh")) {
+            const hr = this.getHours();
+            formatString = formatString.replace("hh", (hr % 12).toString());
+            const am_pm = hr < 12 ? "AM" : "PM";
+            formatString = `${formatString} ${am_pm}`;
+        }
+        return formatString;
+    }
+    getCurrentISODate = () => {
+        return this.toISODate();
+    };
+    toDate = () => {
+        const dateOnly = this.toISODate();
+        return new Date(Date.parse(dateOnly));
+    };
+    getCurrentDate = () => {
+        return new SyzyDate();
+    };
+    currentWeek = () => {
+        const tempDate = new Date(this.getTime());
+        const startOfYear = new Date(tempDate.getFullYear(), 0, 1);
+        const pastDaysOfYear = Math.floor((tempDate.getTime() - startOfYear.getTime()) / 86400000);
+        // Calculate the day of the week (0 for Sunday, 1 for Monday, ..., 6 for Saturday)
+        const dayOfWeek = tempDate.getDay();
+        // Adjust the day count based on the day of the week to align with Sunday as the start of the week
+        const adjustedDayOfYear = pastDaysOfYear - dayOfWeek + (dayOfWeek === 0 ? 0 : 7);
+        const weekNumber = Math.ceil(adjustedDayOfYear / 7);
+        return weekNumber;
+    };
+    currentTerm = () => {
+        let term = 0;
+        const currentMon = this.getMonth() + 1;
+        if (currentMon && currentMon <= 6) {
+            term = 1;
+        }
+        else {
+            term = 2;
+        }
+        return term;
+    };
+    currentQuarter = () => {
+        let quarter = 0;
+        const currentMon = this.getMonth() + 1;
+        if (currentMon >= 1 && currentMon <= 3) {
+            quarter = 1;
+        }
+        else if (currentMon >= 4 && currentMon <= 6) {
+            quarter = 2;
+        }
+        else if (currentMon >= 7 && currentMon <= 9) {
+            quarter = 3;
+        }
+        else if (currentMon >= 10 && currentMon <= 12) {
+            quarter = 4;
+        }
+        return quarter;
+    };
+    getCurrentYrAndMonAndQuarterAndTerm = () => {
+        const currentYr = this.getFullYear();
+        const currentMon = this.getMonth() + 1;
+        const currTerm = this.currentTerm();
+        const currentQuarter = this.currentQuarter();
+        return { currentYr, currentMon, currTerm, currentQuarter };
+    };
+    getWeekNo = () => {
+        const startOfYear = new Date(this.getFullYear(), 0, 1);
+        const pastDaysOfYear = Math.floor((this.getTime() - startOfYear.getTime()) / 86400000);
+        // Calculate the day of the week (0 for Sunday, 1 for Monday, ..., 6 for Saturday)
+        const dayOfWeek = this.getDay();
+        // Adjust the day count based on the day of the week to align with Sunday as the start of the week
+        const adjustedDayOfYear = pastDaysOfYear - dayOfWeek + (dayOfWeek === 0 ? 0 : 7);
+        const weekNumber = Math.ceil(adjustedDayOfYear / 7);
+        return weekNumber;
+    };
+    getcurrentTerm = () => {
+        let term = 0;
+        const currentMon = this.getMonth() + 1;
+        if (currentMon >= 1 && currentMon <= 6) {
+            term = 1; // First term (Jan-Jun)
+        }
+        else {
+            term = 2; // Second term (Jul-Dec)
+        }
+        return term;
+    };
+    getCurrentQuarter = () => {
+        let quarter = 0;
+        const currentMon = this.getMonth() + 1;
+        if (currentMon >= 1 && currentMon <= 3) {
+            quarter = 1; // First quarter (Jan-Mar)
+        }
+        else if (currentMon >= 4 && currentMon <= 6) {
+            quarter = 2; // Second quarter (Apr-Jun)
+        }
+        else if (currentMon >= 7 && currentMon <= 9) {
+            quarter = 3; // Third quarter (Jul-Sep)
+        }
+        else if (currentMon >= 10 && currentMon <= 12) {
+            quarter = 4; // Fourth quarter (Oct-Dec)
+        }
+        return quarter;
+    };
+    getCurrentMonthStartAndEnd = () => {
+        const dt = new Date();
+        const startOfMonth = new Date(dt.getFullYear(), dt.getMonth(), 1);
+        const endOfMonth = new Date(dt.getFullYear(), dt.getMonth() + 1, 0);
+        return { startOfMonth, endOfMonth };
+    };
+    getCurrentTermStartAndEnd = () => {
+        const currentYear = this.getFullYear();
+        let startOfTerm;
+        let endDateOfTerm;
+        if (this.getMonth() < 6) {
+            startOfTerm = new Date(currentYear, 0, 1);
+            endDateOfTerm = new Date(currentYear, 5, 30);
+        }
+        else {
+            // Second term: July to December
+            startOfTerm = new Date(currentYear, 6, 1);
+            endDateOfTerm = new Date(currentYear, 11, 31);
+        }
+        return { startOfTerm, endDateOfTerm };
+    };
+    getCurrentYearStartAndEnd = () => {
+        const currentYear = this.getFullYear();
+        // Start of the year: January 1st
+        const startOfYear = new Date(currentYear, 0, 1);
+        // End of the year: December 31st
+        const endOfYear = new Date(currentYear, 11, 31);
+        return { startOfYear, endOfYear };
+    };
+    getCurrentQuarterStartAndEnd = () => {
+        const currentYear = this.getFullYear();
+        const currentQuarter = this.currentQuarter();
+        let startMonth = 0, endMonth = 0;
+        if (currentQuarter === 1) {
+            startMonth = 1;
+            endMonth = 3;
+        }
+        else if (currentQuarter === 2) {
+            startMonth = 4;
+            endMonth = 6;
+        }
+        else if (currentQuarter === 3) {
+            startMonth = 7;
+            endMonth = 9;
+        }
+        else if (currentQuarter === 4) {
+            startMonth = 10;
+            endMonth = 12;
+        }
+        const startDateOfQuarter = new Date(currentYear, startMonth - 1, 1);
+        const endDateOfQuarter = new Date(currentYear, endMonth, 0);
+        return { startDateOfQuarter, endDateOfQuarter };
+    };
+    getCurrentWeekStartAndEnd = () => {
+        const today = new Date();
+        // Sunday = 0, Monday = 1, ..., Saturday = 6
+        const dayOfWeek = today.getDay();
+        // Calculate Sunday (start of week)
+        const startDateOfWeek = new Date(today);
+        startDateOfWeek.setDate(today.getDate() - dayOfWeek);
+        // Calculate Saturday (end of week)
+        const endDateOfWeek = new Date(today);
+        endDateOfWeek.setDate(today.getDate() + (6 - dayOfWeek));
+        // Clear time part for consistency
+        startDateOfWeek.setHours(0, 0, 0, 0);
+        endDateOfWeek.setHours(23, 59, 59, 999);
+        return { startDateOfWeek, endDateOfWeek };
+    };
+    getSelectedMonthStartAndEnd = (month) => {
+        const dt = new Date();
+        const year = dt.getFullYear(); // You can optionally pass year as well
+        const startOfSelectedMonth = new Date(year, month - 1, 1);
+        const endOfSelectedMonth = new Date(year, month, 0); // 0th day of next month = last day of current month
+        return { startOfSelectedMonth, endOfSelectedMonth };
+    };
+}

package/dist/util/dateUtils.d.ts

@@ -0,0 +1,10 @@
+import { SyzyDate } from "./SyzyDate";
+export declare const DATE_FORMAT_ISO_DD_MON_YYYY = "DD-Mon-YYYY";
+export declare const DATE_FORMAT_ISO_YYYY_MM_DD = "YYYY-MM-DD";
+export declare const DATE_FORMAT_DD_MM_YYYY = "DD-MM-YYYY";
+export declare const DATE_FORMAT_ISO_YYYY_MM_DD_HH_MM = "YYYY-MM-DD HH:mm";
+export declare const DATE_FORMAT_ISO_YYYY_MM_DD_HH_MM_SS = "YYYY-MM-DD HH:mm:ss";
+export declare const DATE_FORMAT_ISO_DD_MON_YYYY_HH_MM = "DD-Mon-YYYY HH:mm";
+export declare const DATE_FORMAT_ISO_DD_MON_YYYY_HH_MM_SS = "DD-Mon-YYYY HH:mm:ss";
+export declare const formatDateWithShortMonth: (isoDateString: string) => string;
+export declare const compareDate: (date1: SyzyDate, date2: SyzyDate) => boolean;

package/dist/util/dateUtils.js

@@ -0,0 +1,24 @@
+import { logger } from "./Logger";
+export const DATE_FORMAT_ISO_DD_MON_YYYY = 'DD-Mon-YYYY';
+export const DATE_FORMAT_ISO_YYYY_MM_DD = 'YYYY-MM-DD';
+export const DATE_FORMAT_DD_MM_YYYY = 'DD-MM-YYYY';
+export const DATE_FORMAT_ISO_YYYY_MM_DD_HH_MM = 'YYYY-MM-DD HH:mm';
+export const DATE_FORMAT_ISO_YYYY_MM_DD_HH_MM_SS = 'YYYY-MM-DD HH:mm:ss';
+export const DATE_FORMAT_ISO_DD_MON_YYYY_HH_MM = 'DD-Mon-YYYY HH:mm';
+export const DATE_FORMAT_ISO_DD_MON_YYYY_HH_MM_SS = 'DD-Mon-YYYY HH:mm:ss';
+export const formatDateWithShortMonth = (isoDateString) => {
+    const date = new Date(isoDateString);
+    return new Intl.DateTimeFormat('en-gb', {
+        day: '2-digit',
+        month: 'short',
+        year: 'numeric',
+    }).format(date);
+};
+export const compareDate = (date1, date2) => {
+    const dateOnly1 = date1.toISODate();
+    const dateOnly2 = date2.toISODate();
+    logger.error("dateOnly1", dateOnly1);
+    logger.error("dateOnly2", dateOnly2);
+    const result = dateOnly1 >= dateOnly2;
+    return result;
+};

package/dist/util/hostedinContainer.d.ts

@@ -0,0 +1 @@
+export declare const isHostedInContainer: () => boolean;

package/dist/util/hostedinContainer.js

@@ -0,0 +1,9 @@
+export const isHostedInContainer = () => {
+    let returnValue = false;
+    const urlParams = new URLSearchParams(window.location.search);
+    if (urlParams.get('hosted_in_container') === 'true') {
+        window.hosted_in_container = true;
+        returnValue = true;
+    }
+    return returnValue;
+};

package/dist/util/model-types.d.ts

@@ -0,0 +1,96 @@
+export type ModelStringKeyConditionInput = {
+    eq?: string | null;
+    le?: string | null;
+    lt?: string | null;
+    ge?: string | null;
+    gt?: string | null;
+    between?: Array<string | null> | null;
+    beginsWith?: string | null;
+};
+export declare enum ModelSortDirection {
+    ASC = "ASC",
+    DESC = "DESC"
+}
+export declare enum ModelAttributeTypes {
+    binary = "binary",
+    binarySet = "binarySet",
+    bool = "bool",
+    list = "list",
+    map = "map",
+    number = "number",
+    numberSet = "numberSet",
+    string = "string",
+    stringSet = "stringSet",
+    _null = "_null"
+}
+export type ModelSizeInput = {
+    ne?: number | null;
+    eq?: number | null;
+    le?: number | null;
+    lt?: number | null;
+    ge?: number | null;
+    gt?: number | null;
+    between?: Array<number | null> | null;
+};
+export type ModelIDInput = {
+    ne?: string | null;
+    eq?: string | null;
+    le?: string | null;
+    lt?: string | null;
+    ge?: string | null;
+    gt?: string | null;
+    contains?: string | null;
+    notContains?: string | null;
+    between?: Array<string | null> | null;
+    in?: Array<string | null> | null;
+    beginsWith?: string | null;
+    attributeExists?: boolean | null;
+    attributeType?: ModelAttributeTypes | null;
+    size?: ModelSizeInput | null;
+};
+export type ModelStringInput = {
+    ne?: string | null;
+    eq?: string | null;
+    le?: string | null;
+    lt?: string | null;
+    ge?: string | null;
+    gt?: string | null;
+    contains?: string | null;
+    notContains?: string | null;
+    between?: Array<string | null> | null;
+    in?: Array<string | null> | null;
+    beginsWith?: string | null;
+    attributeExists?: boolean | null;
+    attributeType?: ModelAttributeTypes | null;
+    size?: ModelSizeInput | null;
+};
+export type ModelIntInput = {
+    ne?: number | null;
+    eq?: number | null;
+    le?: number | null;
+    lt?: number | null;
+    ge?: number | null;
+    gt?: number | null;
+    between?: Array<number | null> | null;
+    in?: Array<number | null> | null;
+    attributeExists?: boolean | null;
+    attributeType?: ModelAttributeTypes | null;
+};
+export type ModelFloatInput = {
+    ne?: number | null;
+    eq?: number | null;
+    le?: number | null;
+    lt?: number | null;
+    ge?: number | null;
+    gt?: number | null;
+    between?: Array<number | null> | null;
+    in?: Array<number | null> | null;
+    attributeExists?: boolean | null;
+    attributeType?: ModelAttributeTypes | null;
+};
+export type ModelBooleanInput = {
+    ne?: boolean | null;
+    eq?: boolean | null;
+    attributeExists?: boolean | null;
+    attributeType?: ModelAttributeTypes | null;
+};

package/dist/util/model-types.js

@@ -0,0 +1,18 @@
+export var ModelSortDirection;
+(function (ModelSortDirection) {
+    ModelSortDirection["ASC"] = "ASC";
+    ModelSortDirection["DESC"] = "DESC";
+})(ModelSortDirection || (ModelSortDirection = {}));
+export var ModelAttributeTypes;
+(function (ModelAttributeTypes) {
+    ModelAttributeTypes["binary"] = "binary";
+    ModelAttributeTypes["binarySet"] = "binarySet";
+    ModelAttributeTypes["bool"] = "bool";
+    ModelAttributeTypes["list"] = "list";
+    ModelAttributeTypes["map"] = "map";
+    ModelAttributeTypes["number"] = "number";
+    ModelAttributeTypes["numberSet"] = "numberSet";
+    ModelAttributeTypes["string"] = "string";
+    ModelAttributeTypes["stringSet"] = "stringSet";
+    ModelAttributeTypes["_null"] = "_null";
+})(ModelAttributeTypes || (ModelAttributeTypes = {}));

package/dist/util/prefixAndResettingValidation.d.ts

@@ -0,0 +1,9 @@
+export declare const validateFullWrapper: (val: string) => string | undefined;
+export declare const validateFirstOccurance: (val: string) => {
+    firstWrapper: string | null;
+    validTokens: string[];
+};
+export declare const resettingOptions: (prefix: string) => {
+    index: number;
+    periods: string[];
+} | null;