@jebgem/model 0.0.1

package/lib/recommendation/recommendation.interface.d.ts

@@ -0,0 +1,63 @@
+import { RecommendationImpactEnum } from './recommendation-impact.enum';
+import { RecommendationEffortEnum } from './recommendation-effort.enum';
+import { MetricEnum } from '../data/metric.enum';
+import { RecommendationInHouseCapabilityEnum } from './recommendation-in-house-capability.enum';
+import { RecommendationExternalAgencyEnum } from './recommendation-external-agency.enum';
+import { RecommendationTechnologyInvestmentEnum } from './recommendation-technology-investment.enum';
+import { RecommendationBusinessObjectiveEnum } from './recommendation-business-objective.enum';
+import { RecommendationCustomerFocusEnum } from './recommendation-customer-focus.enum';
+import { IndirectlyAffectedMetricExplanationInterface } from './indirectly-affected-metric-explanation.interface';
+import { RecommendationMarketingChannelEnum } from './recommendation-marketing-channel.enum';
+import { RecommendationRequiredSkillInterface } from './recommendation-required-skill.interface';
+import { CustomerFocusExplanationDetailsInterface } from './customer-focus-explanation-details.interface';
+import { GlossaryItemInterface } from '../common/glossary-item.interface';
+import { RecommendationTypeEnum } from './recommendation-type.enum';
+import { AppGuidedRecommendationDetailsInterface } from './app-guided-recommendation-details.interface';
+import { AbstractItemChildrenContentInterface } from '../common/item/abstract-item-children-content.interface';
+import { AbstractItemSelfContentInterface } from '../common/item/abstract-item-self-content.interface';
+import { RecommendationStatusEnum } from './recommendation-status.enum';
+import { AbstractItemStatusInterface } from '../common/item/abstract-item-status.interface';
+import { AbstractItemOwnersInterface } from '../common/item/abstract-item-owners.interface';
+import { ExpectationsStatusEnum } from '../integrated-recommendation/expectations-status.enum';
+import { AbstractCommitmentItemInterface } from '../common/item/abstract-commitment-item.interface';
+export declare const RECOMMENDATION_OFFSET_DATE_FIELDS: string[];
+export interface RecommendationInterface extends AbstractItemChildrenContentInterface, AbstractItemSelfContentInterface, AbstractItemStatusInterface, AbstractItemOwnersInterface, AbstractCommitmentItemInterface {
+    directlyAffectedMetric?: MetricEnum;
+    indirectlyAffectedMetrics?: MetricEnum[];
+    strategyId?: number;
+    title?: string;
+    overview?: string;
+    description?: string;
+    inHouseCapabilityRequiredResources?: RecommendationInHouseCapabilityEnum[];
+    externalAgencyRequiredResources?: RecommendationExternalAgencyEnum[];
+    technologyInvestmentRequiredResources?: RecommendationTechnologyInvestmentEnum[];
+    impact?: RecommendationImpactEnum;
+    effort?: RecommendationEffortEnum;
+    type?: RecommendationTypeEnum;
+    businessObjective?: RecommendationBusinessObjectiveEnum;
+    customerFocus?: RecommendationCustomerFocusEnum;
+    customerFocusExplanationDetails?: CustomerFocusExplanationDetailsInterface;
+    marketingChannel?: RecommendationMarketingChannelEnum;
+    directlyAffectedMetricExplanation?: string;
+    indirectlyAffectedMetricsExplanations?: IndirectlyAffectedMetricExplanationInterface[];
+    dependentOnRecommendationIds?: number[];
+    requiredSkills?: RecommendationRequiredSkillInterface[];
+    glossaryItems?: GlossaryItemInterface[];
+    appGuidedRecommendations?: AppGuidedRecommendationDetailsInterface[];
+    idealDirectlyAffectedMetric?: string;
+    idealIndirectlyAffectedMetrics?: string;
+    generallyAvailable?: boolean;
+    strategyRuleId?: number;
+    userStrategySeedId?: number;
+    shopId?: number;
+    integratedRecommendationId?: number;
+    howRelates?: string;
+    status?: RecommendationStatusEnum;
+    rank?: number;
+    recommendedRank?: number;
+    withTasks?: boolean;
+    lastWorkDate?: Date;
+    expectationsStatus?: ExpectationsStatusEnum;
+    remedyRecommendationId?: number;
+    failedRecommendationId?: number;
+}

package/lib/recommendation-library-publish-log/recommendation-library-publish-log.interface.d.ts

@@ -0,0 +1,9 @@
+import { AbstractItemInterface } from '../common/item/abstract-item.interface';
+export interface RecommendationLibraryPublishLogInterface extends AbstractItemInterface {
+    recommendationIds?: number[];
+    userStrategySeedId?: number;
+    generateStrategyRunId?: number;
+    generateRecommendationRunId?: number;
+    generateTaskRunId?: number;
+    generateTaskStepRunId?: number;
+}

package/lib/recommendation-shop-publish-log/recommendation-shop-publish-log.interface.d.ts

@@ -0,0 +1,10 @@
+import { AbstractItemInterface } from '../common/item/abstract-item.interface';
+export interface RecommendationShopPublishLogInterface extends AbstractItemInterface {
+    shopId?: number;
+    recommendationIds?: number[];
+    userStrategySeedId?: number;
+    generateStrategyRunId?: number;
+    generateRecommendationRunId?: number;
+    generateTaskRunId?: number;
+    generateTaskStepRunId?: number;
+}

package/lib/report/ad-platform.enum.d.ts

@@ -0,0 +1,14 @@
+import { PlatformTypeEnum } from './platform-type.enum';
+export declare enum AdPlatformEnum {
+    GOOGLE = "GOOGLE",
+    MICROSOFT = "MICROSOFT",
+    AMAZON = "AMAZON",
+    META = "META",
+    PINTEREST = "PINTEREST",
+    YAHOO_JAPAN = "YAHOO_JAPAN"
+}
+export declare class AdPlatformEnumUtil {
+    static title(adPlatform: AdPlatformEnum): string;
+    static forPlatformType(platformType: PlatformTypeEnum): (AdPlatformEnum | undefined)[];
+    static weight(adPlatform: AdPlatformEnum | undefined): number;
+}

package/lib/report/affiliate-network.enum.d.ts

@@ -0,0 +1,12 @@
+import { PlatformTypeEnum } from "./platform-type.enum";
+export declare enum AffiliateNetworkEnum {
+    COMMISSION_JUNCTION = "COMMISSION_JUNCTION",
+    PEPPER_JAM = "PEPPER_JAM",
+    SHARE_A_SALE = "SHARE_A_SALE",
+    LINK_SHARE = "LINK_SHARE"
+}
+export declare class AffiliateNetworkEnumUtil {
+    static title(affiliateNetwork: AffiliateNetworkEnum): string;
+    static forPlatformType(platformType: PlatformTypeEnum): (AffiliateNetworkEnum | undefined)[];
+    static weight(affiliateNetwork: AffiliateNetworkEnum | undefined): number;
+}

package/lib/report/chart-period.enum.d.ts

@@ -0,0 +1,22 @@
+import { ITimeInterval } from '@amcharts/amcharts5/.internal/core/util/Time';
+import { Dayjs, ManipulateType } from 'dayjs';
+import { ConvertedRowStore } from '../data/results/row/converted-row.store';
+export declare enum ChartPeriodEnum {
+    DAILY = "DAILY",
+    WEEKLY = "WEEKLY",
+    MONTHLY = "MONTHLY"
+}
+export declare class ChartPeriodEnumUtil {
+    static rowStoreDate(chartPeriod: ChartPeriodEnum | undefined, rowStore: ConvertedRowStore): Dayjs | undefined;
+    static dateFormatPrepend(chartPeriod: ChartPeriodEnum): string;
+    static dateFormat(chartPeriod: ChartPeriodEnum): string;
+    static title(chartPeriod: ChartPeriodEnum): string;
+    static baseTimeInterval(trendChartPeriod: ChartPeriodEnum | undefined): ITimeInterval | undefined;
+    static timeUnit(trendChartPeriod: ChartPeriodEnum): ManipulateType;
+    static addPeriodToDateTime(dayjs: Dayjs, trendChartPeriod: ChartPeriodEnum | undefined, { value, }?: {
+        value?: number;
+    }): Dayjs;
+    static subtractPeriodToDateTime(dateTime: number, trendChartPeriod: ChartPeriodEnum | undefined, { value, }?: {
+        value?: number;
+    }): number;
+}

package/lib/report/compare-date-range-type.enum.d.ts

@@ -0,0 +1,11 @@
+import { DateTimesInterface } from "./date-times.interface";
+export declare enum CompareDateRangeTypeEnum {
+    NONE = "NONE",
+    PREVIOUS_PERIOD = "PREVIOUS_PERIOD",
+    SAME_PERIOD_LAST_YEAR = "SAME_PERIOD_LAST_YEAR",
+    CUSTOM = "CUSTOM"
+}
+export declare class CompareDateRangeTypeEnumUtil {
+    static title(type: CompareDateRangeTypeEnum): string;
+    static compareDateTimes(type: CompareDateRangeTypeEnum, customCompareStartDate: Date | undefined, customCompareEndDate: Date | undefined, dateTimes: DateTimesInterface): DateTimesInterface;
+}

package/lib/report/currency-code.enum.d.ts

@@ -0,0 +1,38 @@
+export declare enum CurrencyCodeEnum {
+    AED = "AED",
+    AUD = "AUD",
+    BGN = "BGN",
+    BRL = "BRL",
+    CAD = "CAD",
+    CHF = "CHF",
+    CNY = "CNY",
+    COP = "COP",
+    CZK = "CZK",
+    DKK = "DKK",
+    EUR = "EUR",
+    GBP = "GBP",
+    HKD = "HKD",
+    HRK = "HRK",
+    HUF = "HUF",
+    IDR = "IDR",
+    ILS = "ILS",
+    INR = "INR",
+    ISK = "ISK",
+    JPY = "JPY",
+    KRW = "KRW",
+    LTL = "LTL",
+    MXN = "MXN",
+    MYR = "MYR",
+    NOK = "NOK",
+    NZD = "NZD",
+    PHP = "PHP",
+    PLN = "PLN",
+    RON = "RON",
+    RUB = "RUB",
+    SAR = "SAR",
+    SEK = "SEK",
+    SGD = "SGD",
+    THB = "THB",
+    USD = "USD",
+    ZAR = "ZAR"
+}

package/lib/report/date-info.interface.d.ts

@@ -0,0 +1,10 @@
+import { DateRangeTypeEnum } from './date-range-type.enum';
+import { CompareDateRangeTypeEnum } from './compare-date-range-type.enum';
+export interface DateInfoInterface {
+    dateRangeType: DateRangeTypeEnum;
+    customStartDate?: Date;
+    customEndDate?: Date;
+    compareDateRangeType: CompareDateRangeTypeEnum;
+    customCompareStartDate?: Date;
+    customCompareEndDate?: Date;
+}

package/lib/report/date-range-type.enum.d.ts

@@ -0,0 +1,25 @@
+import { DateTimesInterface } from './date-times.interface';
+export declare enum DateRangeTypeEnum {
+    YESTERDAY = "YESTERDAY",
+    LAST_7_DAYS = "LAST_7_DAYS",
+    LAST_14_DAYS = "LAST_14_DAYS",
+    LAST_28_DAYS = "LAST_28_DAYS",
+    LAST_30_DAYS = "LAST_30_DAYS",
+    LAST_60_DAYS = "LAST_60_DAYS",
+    LAST_90_DAYS = "LAST_90_DAYS",
+    LAST_180_DAYS = "LAST_180_DAYS",
+    LAST_360_DAYS = "LAST_360_DAYS",
+    THIS_MONTH = "THIS_MONTH",
+    LAST_MONTH = "LAST_MONTH",
+    THIS_QUARTER = "THIS_QUARTER",
+    LAST_QUARTER = "LAST_QUARTER",
+    THIS_YEAR = "THIS_YEAR",
+    LAST_YEAR = "LAST_YEAR",
+    THIS_AND_LAST_YEAR = "THIS_AND_LAST_YEAR",
+    CUSTOM = "CUSTOM",
+    CUSTOM_UNTIL_YESTERDAY = "CUSTOM_UNTIL_YESTERDAY"
+}
+export declare class DateRangeTypeEnumUtil {
+    static title(type: DateRangeTypeEnum): string;
+    static dateTimes(type: DateRangeTypeEnum, customStartDate: Date | undefined, customEndDate: Date | undefined): DateTimesInterface;
+}

package/lib/report/date-times.interface.d.ts

@@ -0,0 +1,5 @@
+import { Dayjs } from 'dayjs';
+export interface DateTimesInterface {
+    startDayjs: Dayjs;
+    endDayjs: Dayjs;
+}

package/lib/report/fake-agency.enum.d.ts

@@ -0,0 +1,11 @@
+import { PlatformTypeEnum } from './platform-type.enum';
+export declare enum FakeAgencyEnum {
+    AGENCY_A = "AGENCY_A",
+    AGENCY_B = "AGENCY_B",
+    AGENCY_C = "AGENCY_C"
+}
+export declare class FakeAgencyEnumUtil {
+    static title(fakeAgency: FakeAgencyEnum): string;
+    static forPlatformType(platformType: PlatformTypeEnum): (FakeAgencyEnum | undefined)[];
+    static weight(adPlatform: FakeAgencyEnum | undefined): number;
+}

package/lib/report/marketing-channel.enum.d.ts

@@ -0,0 +1,20 @@
+import { PlatformTypeEnum } from "./platform-type.enum";
+import { AffiliateNetworkEnum } from "./affiliate-network.enum";
+import { AdPlatformEnum } from "./ad-platform.enum";
+import { FakeAgencyEnum } from "./fake-agency.enum";
+export declare enum MarketingChannelEnum {
+    ORGANIC_SEARCH = "ORGANIC_SEARCH",
+    PAID_SEARCH = "PAID_SEARCH",
+    DISPLAY = "DISPLAY",
+    DIRECT = "DIRECT",
+    SOCIAL = "SOCIAL",
+    EMAIL = "EMAIL",
+    AFFILIATE = "AFFILIATE",
+    REFERRAL = "REFERRAL",
+    OTHER = "OTHER"
+}
+export declare class MarketingChannelEnumUtil {
+    static title(channel: MarketingChannelEnum): string;
+    static forPlatformType(platformType: PlatformTypeEnum): MarketingChannelEnum[];
+    static weight(platformType: PlatformTypeEnum, marketingChannel: MarketingChannelEnum, affiliateNetwork: AffiliateNetworkEnum | undefined, adPlatform: AdPlatformEnum | undefined, fakeAgency: FakeAgencyEnum | undefined): number;
+}

package/lib/report/platform-type.enum.d.ts

@@ -0,0 +1,9 @@
+export declare enum PlatformTypeEnum {
+    ADS = "ADS",
+    AFFILIATE = "AFFILIATE",
+    STORE = "STORE",
+    AGENCY = "AGENCY"
+}
+export declare class PlatformTypeEnumUtil {
+    static title(type: PlatformTypeEnum): string;
+}

package/lib/report/report-search-query.interface.d.ts

@@ -0,0 +1,4 @@
+import { DateInfoInterface } from "./date-info.interface";
+export interface ReportSearchQueryInterface {
+    dateInfo: DateInfoInterface;
+}

package/lib/report/report-total-row.interface.d.ts

@@ -0,0 +1,19 @@
+import { PlatformTypeEnum } from "./platform-type.enum";
+import { MarketingChannelEnum } from "./marketing-channel.enum";
+import { AffiliateNetworkEnum } from "./affiliate-network.enum";
+import { AdPlatformEnum } from "./ad-platform.enum";
+import { FakeAgencyEnum } from "./fake-agency.enum";
+export interface ReportTotalRowInterface {
+    trendStartDate: Date;
+    cost?: number;
+    value?: number;
+    productCosts?: number;
+    shippingFees?: number;
+    creditCardFees?: number;
+    contributionProfit?: number;
+    platformType: PlatformTypeEnum;
+    marketingChannel: MarketingChannelEnum;
+    affiliateNetwork?: AffiliateNetworkEnum;
+    adPlatform?: AdPlatformEnum;
+    fakeAgency?: FakeAgencyEnum;
+}

package/lib/report/report.interface.d.ts

@@ -0,0 +1,9 @@
+import { ReportTotalRowInterface } from './report-total-row.interface';
+import { CurrencyCodeEnum } from './currency-code.enum';
+import { ChartPeriodEnum } from './chart-period.enum';
+export interface ReportInterface {
+    determinedChartPeriod: ChartPeriodEnum;
+    currencyCode: CurrencyCodeEnum;
+    trendReportTotalRows?: ReportTotalRowInterface[];
+    compareTrendReportTotalRows?: ReportTotalRowInterface[];
+}

package/lib/report/store-cost-type.enum.d.ts

@@ -0,0 +1,11 @@
+import { ReportTotalRowInterface } from "./report-total-row.interface";
+export declare enum StoreCostTypeEnum {
+    PRODUCT_COSTS = "PRODUCT_COSTS",
+    CREDIT_CARD_FEES = "CREDIT_CARD_FEES",
+    SHIPPING_FEES = "SHIPPING_FEES"
+}
+export declare class StoreCostTypeEnumUtil {
+    static title(type: StoreCostTypeEnum): string;
+    static reportTotalRowKey(storeCostType: StoreCostTypeEnum | undefined): keyof ReportTotalRowInterface;
+    static costByValue(storeCostType: StoreCostTypeEnum, value: number): number;
+}

package/lib/search/abstract-base-search-results.interface.d.ts

@@ -0,0 +1,5 @@
+export interface AbstractBaseSearchResultsInterface {
+    countOfAllMatchingItems?: number;
+    pageSize: number;
+    pageIndex: number;
+}

package/lib/settings/chart-compare-type.enum.d.ts

@@ -0,0 +1,8 @@
+export declare enum ChartCompareTypeEnum {
+    ON_TOP = "ON_TOP",
+    SUBSEQUENT = "SUBSEQUENT",
+    NO_CHART = "NO_CHART"
+}
+export declare class ChartCompareTypeEnumUtil {
+    static title(type: ChartCompareTypeEnum): string;
+}

package/lib/shop/shop-avatar-color.enum.d.ts

@@ -0,0 +1,17 @@
+export declare enum ShopAvatarColorEnum {
+    HEX_67b7dc = "HEX_67b7dc",
+    HEX_6771dc = "HEX_6771dc",
+    HEX_a367dc = "HEX_a367dc",
+    HEX_dc67ce = "HEX_dc67ce",
+    HEX_dc6788 = "HEX_dc6788",
+    HEX_dc8c67 = "HEX_dc8c67",
+    HEX_dcd267 = "HEX_dcd267",
+    HEX_a0dc67 = "HEX_a0dc67",
+    HEX_67dc75 = "HEX_67dc75",
+    HEX_67dcbb = "HEX_67dcbb"
+}
+export declare class ShopAvatarColorEnumUtil {
+    static twBgClass(color: ShopAvatarColorEnum): string;
+    static twBgClassForInd(ind: number): string;
+    static twFgClass(color: ShopAvatarColorEnum | undefined): string;
+}

package/lib/shop/shop-data-load-status.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum ShopDataLoadStatusEnum {
+    NOT_LOADED = "NOT_LOADED",
+    INITIAL_LOADED = "INITIAL_LOADED",
+    FULLY_LOADED = "FULLY_LOADED"
+}

package/lib/shop/shop-profile-status.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum ShopProfileStatusEnum {
+    NOT_STARTED = "NOT_STARTED",
+    FOCUS_AREA_DETAILS_COMPLETED = "FOCUS_AREA_DETAILS_COMPLETED",
+    FULLY_PROFILED = "FULLY_PROFILED"
+}

package/lib/shop/shop-status.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum ShopStatusEnum {
+    ONBOARDING = "ONBOARDING",
+    ACTIVE = "ACTIVE"
+}

package/lib/shop/shop-type.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum ShopTypeEnum {
+    CUSTOMER = "CUSTOMER",
+    DEMO = "DEMO"
+}

package/lib/shop/shop.interface.d.ts

@@ -0,0 +1,38 @@
+import { AbstractItemInterface } from '../common/item/abstract-item.interface';
+import { ShopTypeEnum } from './shop-type.enum';
+import { ShopStatusEnum } from './shop-status.enum';
+import { ShopDataLoadStatusEnum } from './shop-data-load-status.enum';
+import { ShopAvatarColorEnum } from './shop-avatar-color.enum';
+import { OnboardingStepEnum } from '../user/onboarding-step.enum';
+import { AiDynamicContentStatusEnum } from '../common/ai-dynamic-content-status.enum';
+import { AnomalyStatusEnum } from '../anomaly/anomaly-status.enum';
+import { ShopProfileStatusEnum } from './shop-profile-status.enum';
+export declare const SHOP_OFFSET_DATE_TIME_FIELDS: string[];
+export declare const SHOP_LOCAL_DATE_TIME_FIELDS: string[];
+export interface ShopInterface extends AbstractItemInterface {
+    name?: string;
+    url?: string | null;
+    type?: ShopTypeEnum;
+    status?: ShopStatusEnum;
+    dataLoadStatus?: ShopDataLoadStatusEnum;
+    industryIds?: number[];
+    shopPlatformId?: number;
+    gaPropertyId?: number;
+    lastDataPulledDate?: Date;
+    avatarColor?: ShopAvatarColorEnum;
+    completedOnboardingStep?: OnboardingStepEnum;
+    purchasedCreditCount?: number;
+    initialDataPullDate?: Date;
+    externalWorkBatchCompleted?: boolean;
+    calculatorStarted?: boolean;
+    calculatorCompleted?: boolean;
+    dashboardStarted?: boolean;
+    profileStatus?: ShopProfileStatusEnum;
+    focusAreasVersion?: number;
+    focusAreasContentStatus?: AiDynamicContentStatusEnum;
+    focusAreasContentStartedDate?: Date;
+    focusAreasContentCompletedDate?: Date;
+    anomalyStatus?: AnomalyStatusEnum;
+    onboardingDataPulled?: boolean;
+    otherPlatformName?: string;
+}

package/lib/shop-platform/shop-platform-constants.d.ts

@@ -0,0 +1,8 @@
+export declare class ShopPlatformConstants {
+    static readonly SHOPIFY_ID: number;
+    static readonly WOOCOMMERCE_ID: number;
+    static readonly OTHER_ID: number;
+    static readonly SHOPIFY_NAME: string;
+    static readonly WOOCOMMERCE_NAME: string;
+    static readonly OTHER_NAME: string;
+}

package/lib/shop-platform/shop-platform.interface.d.ts

@@ -0,0 +1,5 @@
+import { AbstractItemInterface } from '../common/item/abstract-item.interface';
+export interface ShopPlatformInterface extends AbstractItemInterface {
+    name?: string;
+    supported?: boolean;
+}

package/lib/strategy/category/tree/strategy-category-tree.interface.d.ts

@@ -0,0 +1,12 @@
+export interface StrategyCategoryTreeInterface {
+    rootId?: number;
+    down1Id?: number;
+    down2Id?: number;
+    rootName?: string;
+    down1Name?: string;
+    down2Name?: string;
+    rootDescription?: string;
+    down1Description?: string;
+    down2Description?: string;
+    strategyCount?: number;
+}

package/lib/strategy/link/strategy-link.interface.d.ts

@@ -0,0 +1,5 @@
+import { AbstractItemShopInterface } from '../../common/item/abstract-item-shop.interface';
+export interface StrategyLinkInterface extends AbstractItemShopInterface {
+    strategyId?: number;
+    parentStrategyId?: number;
+}

package/lib/strategy/strategy-origin.enum.d.ts

@@ -0,0 +1,10 @@
+export declare enum StrategyOriginEnum {
+    EXTERNAL = "EXTERNAL",
+    FOCUS_AREA = "FOCUS_AREA",
+    FUNNEL_ANALYSIS = "FUNNEL_ANALYSIS",
+    FUNNEL_ANALYSIS_METRIC = "FUNNEL_ANALYSIS_METRIC",
+    BUSINESS_GOAL_OBJECTIVE = "BUSINESS_GOAL_OBJECTIVE",
+    SPECIFIC_METRIC = "SPECIFIC_METRIC",
+    NEXT = "NEXT",
+    UNKNOWN = "UNKNOWN"
+}

package/lib/strategy/strategy-status.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum StrategyStatusEnum {
+    STAGING = "STAGING",
+    PRODUCTION = "PRODUCTION"
+}

package/lib/strategy/strategy-workflow-status.enum.d.ts

@@ -0,0 +1,14 @@
+export declare enum StrategyWorkflowStatusEnum {
+    POTENTIAL = "POTENTIAL",
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE",
+    WISHLIST = "WISHLIST"
+}
+export declare class StrategyWorkflowStatusEnumUtil {
+    static backLabel(workflowStatus: StrategyWorkflowStatusEnum | undefined, { includeActive, }?: {
+        includeActive?: boolean;
+    }): string;
+    static title(workflowStatus: StrategyWorkflowStatusEnum | undefined, { includeActive, }?: {
+        includeActive?: boolean;
+    }): string;
+}

package/lib/strategy/strategy.interface.d.ts

@@ -0,0 +1,40 @@
+import { AbstractItemInterface } from '../common/item/abstract-item.interface';
+import { RecommendationTypeEnum } from '../recommendation/recommendation-type.enum';
+import { StrategyStatusEnum } from './strategy-status.enum';
+import { MetricEnum } from '../data/metric.enum';
+import { AbstractItemChildrenContentInterface } from '../common/item/abstract-item-children-content.interface';
+import { StrategyLinkInterface } from './link/strategy-link.interface';
+import { StrategyOriginEnum } from './strategy-origin.enum';
+import { StrategyWorkflowStatusEnum } from './strategy-workflow-status.enum';
+import { AbstractItemSubsequentChildrenContentInterface } from '../common/item/abstract-item-subsequent-children-content.interface';
+import { AbstractItemStatusInterface } from '../common/item/abstract-item-status.interface';
+import { AbstractItemOwnersInterface } from '../common/item/abstract-item-owners.interface';
+export interface StrategyInterface extends AbstractItemInterface, AbstractItemChildrenContentInterface, AbstractItemSubsequentChildrenContentInterface, AbstractItemStatusInterface, AbstractItemOwnersInterface {
+    categoryId?: number;
+    code?: string;
+    title?: string;
+    subtitle?: string;
+    howRelates?: string;
+    rank?: number;
+    recommendedRank?: number;
+    description?: string;
+    recommendationTypes?: RecommendationTypeEnum[];
+    generatingStrategySeedId?: number;
+    status?: StrategyStatusEnum;
+    workflowStatus?: StrategyWorkflowStatusEnum;
+    implementRules?: string[];
+    shopPlannedRecommendationIds?: number[];
+    shopInProgressRecommendationIds?: number[];
+    shopCompletedRecommendationIds?: number[];
+    shopCommittedMetrics?: MetricEnum[];
+    shopLibraryMetrics?: MetricEnum[];
+    specificStrategyId?: number;
+    shopId?: number;
+    parentStrategyLink?: StrategyLinkInterface;
+    childrenStrategyLinks?: StrategyLinkInterface[];
+    parentStrategy?: StrategyInterface;
+    childrenStrategies?: StrategyInterface[];
+    activityTypeId?: number;
+    businessGoalObjectiveId?: number;
+    origin?: StrategyOriginEnum;
+}

package/lib/strategy-rule/rule-item.interface.d.ts

@@ -0,0 +1,2 @@
+import { AbstractItemTitleDescriptionInterface } from '../common/item/abstract-item-title-description.interface';
+export type RuleItemInterface = AbstractItemTitleDescriptionInterface;

package/lib/strategy-rule/rules-type.enum.d.ts

@@ -0,0 +1,7 @@
+export declare enum RulesTypeEnum {
+    OPTIMIZE = "OPTIMIZE",
+    MARKET = "MARKET"
+}
+export declare class RulesTypeEnumUtil {
+    static title(rulesType: RulesTypeEnum | undefined): string;
+}

package/lib/strategy-rule/strategy-rule.interface.d.ts

@@ -0,0 +1,22 @@
+import { AbstractItemInterface } from '../common/item/abstract-item.interface';
+import { RuleItemInterface } from './rule-item.interface';
+import { AiDynamicContentStatusEnum } from '../common/ai-dynamic-content-status.enum';
+import { AbstractItemSelfContentInterface } from '../common/item/abstract-item-self-content.interface';
+import { AbstractItemChildrenContentInterface } from '../common/item/abstract-item-children-content.interface';
+import { RulesTypeEnum } from './rules-type.enum';
+export interface StrategyRuleInterface extends AbstractItemInterface, AbstractItemSelfContentInterface, AbstractItemChildrenContentInterface {
+    strategyId?: number;
+    strategySeedId?: number;
+    marketRules?: string[];
+    optimizeRules?: string[];
+    marketRuleItems?: RuleItemInterface[];
+    optimizeRuleItems?: RuleItemInterface[];
+    selectedMarketRuleItems?: RuleItemInterface[];
+    selectedOptimizeRuleItems?: RuleItemInterface[];
+    selfContentStatus?: AiDynamicContentStatusEnum;
+    selfContentStartedDate?: Date;
+    selfContentCompletedDate?: Date;
+    rulesType?: RulesTypeEnum;
+    recommendationShopPublishLogId?: number;
+    nextStrategyIds?: number[];
+}

package/lib/strategy-seed/strategy-seed-status.enum.d.ts

@@ -0,0 +1,15 @@
+import { UiThemeEnum } from '@jebgem/util';
+export declare enum StrategySeedStatusEnum {
+    GENERATING_OBJECTIVE = "GENERATING_OBJECTIVE",
+    PENDING = "PENDING",
+    REQUESTED = "REQUESTED",
+    GENERATING = "GENERATING",
+    PUBLISHED = "PUBLISHED",
+    MORE_INFO_NEEDED = "MORE_INFO_NEEDED"
+}
+export declare class StrategySeedStatusEnumUtil {
+    static title(status: StrategySeedStatusEnum | undefined): string;
+    static description(status: StrategySeedStatusEnum | undefined): string;
+    static statusBodyDescription(status: StrategySeedStatusEnum | undefined): string | undefined;
+    static uiTheme(status: StrategySeedStatusEnum): UiThemeEnum;
+}

package/lib/strategy-seed/strategy-seed-type.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum StrategySeedTypeEnum {
+    USER = "USER",
+    OPERATIONS = "OPERATIONS"
+}

package/lib/strategy-seed/strategy-seed.interface.d.ts

@@ -0,0 +1,35 @@
+import { AbstractItemInterface } from '../common/item/abstract-item.interface';
+import { MetricEnum } from '../data/metric.enum';
+import { RecommendationBusinessObjectiveEnum } from '../recommendation/recommendation-business-objective.enum';
+import { RecommendationCustomerFocusEnum } from '../recommendation/recommendation-customer-focus.enum';
+import { RecommendationMarketingChannelEnum } from '../recommendation/recommendation-marketing-channel.enum';
+import { RecommendationTypeEnum } from '../recommendation/recommendation-type.enum';
+import { StrategySeedTypeEnum } from './strategy-seed-type.enum';
+import { StrategySeedStatusEnum } from './strategy-seed-status.enum';
+import { UserStrategySeedOriginEnum } from './user-strategy-seed-origin.enum';
+import { AbstractItemChildrenContentInterface } from '../common/item/abstract-item-children-content.interface';
+import { AbstractItemSubsequentChildrenContentInterface } from '../common/item/abstract-item-subsequent-children-content.interface';
+export interface StrategySeedInterface extends AbstractItemInterface, AbstractItemChildrenContentInterface, AbstractItemSubsequentChildrenContentInterface {
+    recommendationTypes?: RecommendationTypeEnum[];
+    recommendationBusinessObjectives?: RecommendationBusinessObjectiveEnum[];
+    recommendationMarketingChannels?: RecommendationMarketingChannelEnum[];
+    recommendationCustomerFocuses?: RecommendationCustomerFocusEnum[];
+    recommendationDirectlyAffectedMetrics?: MetricEnum[];
+    openEndedObjectives?: string[];
+    type?: StrategySeedTypeEnum;
+    userStrategySeedOrigin?: UserStrategySeedOriginEnum;
+    status?: StrategySeedStatusEnum;
+    shopId?: number;
+    notifyUserIds?: number[];
+    strategyExtractedInstructions?: string;
+    recommendationExtractedInstructions?: string;
+    recommendedActionId?: number;
+    specificStrategyIds?: number[];
+    businessIssuePromptOptionIds?: number[];
+    businessIssueId?: number;
+    businessIssueCategoryId?: number;
+    publishedStrategyIds?: number[];
+    publishedRecommendationIds?: number[];
+    objectiveTitle?: string;
+    actOnMetricBatchId?: number[];
+}