@maxio-com/self-service 1.0.2

package/typings/packages/subscriptions-manager/src/machines/index.d.ts

@@ -0,0 +1,13 @@
+import { productCatalog, productCatalogSelectors, ProductCatalogInterpreter } from './productCatalog';
+import { subscriptionSelectors } from './subscription';
+import { createSubscriptionsMachine, subscriptionsSelectors, SubscriptionsInterpreter, SubscriptionRef, DEFAULT_VISIBLE_SUBSCRIPTIONS } from './subscriptions';
+import { modals, modalsSelectors, ModalsInterpreter } from './modals';
+import { componentSelectors } from './component';
+import { componentsSelectors } from './components';
+import { createPaymentProfile, paymentProfileSelectors, PaymentProfileInterpreter, PaymentProfileFields, PaymentProfileFromType, PaymentProfileFieldError, PaymentMethod } from './createPaymentProfile';
+import { paymentGateway, paymentGatewaySelectors, PaymentGatewayInterpreter } from './paymentGateway';
+import { paymentProfiles, paymentProfilesSelectors, PaymentProfilesInterpreter } from './paymentProfiles';
+import { addOnsConfiguration, Allocation, SerializedPrice, SerializedComponent, AllocationsPreview, AddonsConfigurationContext, AllocationsError, AddonsInterpreter } from './addOnsConfiguration';
+export { modals, modalsSelectors, createSubscriptionsMachine, subscriptionsSelectors, subscriptionSelectors, productCatalogSelectors, componentSelectors, componentsSelectors, paymentGatewaySelectors, paymentGateway, productCatalog, paymentProfiles, paymentProfilesSelectors, createPaymentProfile, paymentProfileSelectors, addOnsConfiguration, };
+export type { PaymentProfilesInterpreter, SubscriptionsInterpreter, SubscriptionRef, ProductCatalogInterpreter, PaymentProfileInterpreter, AddonsInterpreter, PaymentProfileFromType, PaymentProfileFieldError, PaymentProfileFields, ModalsInterpreter, Allocation, SerializedComponent, SerializedPrice, AllocationsPreview, AddonsConfigurationContext, PaymentMethod, PaymentGatewayInterpreter, AllocationsError, };
+export { DEFAULT_VISIBLE_SUBSCRIPTIONS };

package/typings/packages/subscriptions-manager/src/machines/modals/index.d.ts

@@ -0,0 +1,5 @@
+import { modals } from './modals';
+import { modalsSelectors } from './selectors';
+import { ModalsInterpreter } from './types';
+export { modals, modalsSelectors };
+export type { ModalsInterpreter };

package/typings/packages/subscriptions-manager/src/machines/modals/modals.d.ts

@@ -0,0 +1,5 @@
+import { Context, Events } from './types';
+export declare const modals: import("xstate").StateMachine<Context, any, Events, {
+    value: any;
+    context: Context;
+}, import("xstate").BaseActionObject, import("xstate").ServiceMap, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, Events, import("xstate").BaseActionObject, import("xstate").ServiceMap>>;

package/typings/packages/subscriptions-manager/src/machines/modals/selectors.d.ts

@@ -0,0 +1,155 @@
+import { State } from 'xstate';
+import { modals } from './modals';
+declare type ModalsMachine = typeof modals;
+declare type ModalsState = State<ModalsMachine['context']>;
+export declare const getCreatePaymentProfile: (machineState: ModalsState) => {
+    isOpen: boolean;
+    meta: {
+        subscriptionId: number;
+        catalogId: number;
+        paymentMethod: import("..").PaymentMethod;
+    };
+};
+export declare const getAddonsConfiguration: (machineState: ModalsState) => {
+    isOpen: boolean;
+    meta: {
+        subscriptionId: number;
+        catalogId: number;
+    };
+};
+export declare const getResumeSubscription: (machineState: ModalsState) => {
+    isOpen: boolean;
+    meta: {
+        subscriptionId: number;
+        catalogId: number;
+    };
+};
+export declare const getPauseSubscription: (machineState: ModalsState) => {
+    isOpen: boolean;
+    meta: {
+        subscriptionId: number;
+        catalogId: number;
+    };
+};
+export declare const getCancelSubscription: (machineState: ModalsState) => {
+    isOpen: boolean;
+    meta: {
+        subscriptionId: number;
+        catalogId: number;
+    };
+};
+export declare const getDeletePaymentMethod: (machineState: ModalsState) => {
+    isOpen: boolean;
+    meta: {
+        catalogId: number;
+        subscriptionId: number;
+        paymentProfileId: number;
+    };
+};
+export declare const getChangePaymentMethod: (machineState: ModalsState) => {
+    isOpen: boolean;
+    meta: {
+        catalogId: number;
+        subscriptionId: number;
+        paymentProfileId: number;
+    };
+};
+export declare const getPreviewPaymentMethod: (machineState: ModalsState) => {
+    isOpen: boolean;
+    meta: {
+        catalogId: number;
+        subscriptionId: number;
+        paymentProfileId: number;
+    };
+};
+export declare const getUndoCancelation: (machineState: ModalsState) => {
+    isOpen: boolean;
+    meta: {
+        subscriptionId: number;
+        catalogId: number;
+    };
+};
+export declare const getReactivateSubscription: (machineState: ModalsState) => {
+    isOpen: boolean;
+    meta: {
+        subscriptionId: number;
+        catalogId: number;
+    };
+};
+export declare const modalsSelectors: {
+    getCreatePaymentProfile: (machineState: ModalsState) => {
+        isOpen: boolean;
+        meta: {
+            subscriptionId: number;
+            catalogId: number;
+            paymentMethod: import("..").PaymentMethod;
+        };
+    };
+    getAddonsConfiguration: (machineState: ModalsState) => {
+        isOpen: boolean;
+        meta: {
+            subscriptionId: number;
+            catalogId: number;
+        };
+    };
+    getResumeSubscription: (machineState: ModalsState) => {
+        isOpen: boolean;
+        meta: {
+            subscriptionId: number;
+            catalogId: number;
+        };
+    };
+    getPauseSubscription: (machineState: ModalsState) => {
+        isOpen: boolean;
+        meta: {
+            subscriptionId: number;
+            catalogId: number;
+        };
+    };
+    getCancelSubscription: (machineState: ModalsState) => {
+        isOpen: boolean;
+        meta: {
+            subscriptionId: number;
+            catalogId: number;
+        };
+    };
+    getUndoCancelation: (machineState: ModalsState) => {
+        isOpen: boolean;
+        meta: {
+            subscriptionId: number;
+            catalogId: number;
+        };
+    };
+    getDeletePaymentMethod: (machineState: ModalsState) => {
+        isOpen: boolean;
+        meta: {
+            catalogId: number;
+            subscriptionId: number;
+            paymentProfileId: number;
+        };
+    };
+    getChangePaymentMethod: (machineState: ModalsState) => {
+        isOpen: boolean;
+        meta: {
+            catalogId: number;
+            subscriptionId: number;
+            paymentProfileId: number;
+        };
+    };
+    getPreviewPaymentMethod: (machineState: ModalsState) => {
+        isOpen: boolean;
+        meta: {
+            catalogId: number;
+            subscriptionId: number;
+            paymentProfileId: number;
+        };
+    };
+    getReactivateSubscription: (machineState: ModalsState) => {
+        isOpen: boolean;
+        meta: {
+            subscriptionId: number;
+            catalogId: number;
+        };
+    };
+};
+export {};

package/typings/packages/subscriptions-manager/src/machines/modals/types.d.ts

@@ -0,0 +1,96 @@
+import { Interpreter } from 'xstate';
+import { PaymentMethod } from '../createPaymentProfile';
+export declare type Context = {
+    deletePaymentProfile: {
+        catalogId: number | null;
+        subscriptionId: number | null;
+        paymentProfileId: number | null;
+    };
+    createPaymentProfile: {
+        subscriptionId: null | number;
+        catalogId: null | number;
+        paymentMethod: PaymentMethod;
+    };
+    previewPaymentProfile: {
+        catalogId: number | null;
+        subscriptionId: number | null;
+        paymentProfileId: number | null;
+    };
+    changePaymentProfile: {
+        catalogId: number | null;
+        subscriptionId: number | null;
+        paymentProfileId: number | null;
+    };
+    componentsAllocation: {
+        subscriptionId: number | null;
+        catalogId: number | null;
+    };
+    resumeSubscription: {
+        subscriptionId: number | null;
+        catalogId: number | null;
+    };
+    pauseSubscription: {
+        subscriptionId: number | null;
+        catalogId: number | null;
+    };
+    cancelSubscription: {
+        subscriptionId: number | null;
+        catalogId: number | null;
+    };
+    undoCancelation: {
+        subscriptionId: number | null;
+        catalogId: number | null;
+    };
+    reactivateSubscription: {
+        subscriptionId: number | null;
+        catalogId: number | null;
+    };
+};
+export declare type Events = {
+    type: 'CLOSE_MODAL';
+} | {
+    type: 'SHOW_CREATE_PAYMENT_PROFILE';
+    catalogId: number;
+    subscriptionId: number;
+    paymentMethod: PaymentMethod;
+} | {
+    type: 'SHOW_CHANGE_PAYMENT_PROFILE';
+    catalogId: number;
+    subscriptionId: number;
+    paymentProfileId: number;
+} | {
+    type: 'SHOW_PREVIEW_PAYMENT_PROFILE';
+    catalogId: number;
+    subscriptionId: number;
+    paymentProfileId: number;
+} | {
+    type: 'SHOW_ADDONS_CONFIGURATION';
+    catalogId: number;
+    subscriptionId: number;
+} | {
+    type: 'SHOW_DELETE_PAYMENT_PROFILE';
+    catalogId: number;
+    subscriptionId: number;
+    paymentProfileId: number;
+} | {
+    type: 'SHOW_RESUME_SUBSCRIPTION';
+    subscriptionId: number;
+    catalogId: number;
+} | {
+    type: 'SHOW_PAUSE_SUBSCRIPTION';
+    catalogId: number;
+    subscriptionId: number;
+} | {
+    type: 'SHOW_CANCEL_SUBSCRIPTION';
+    catalogId: number;
+    subscriptionId: number;
+} | {
+    type: 'SHOW_UNDO_CANCELATION';
+    catalogId: number;
+    subscriptionId: number;
+} | {
+    type: 'SHOW_REACTIVATE_SUBSCRIPTION';
+    catalogId: number;
+    subscriptionId: number;
+};
+export declare type ModalsInterpreter = Interpreter<Context, Record<string, any>, Events>;

package/typings/packages/subscriptions-manager/src/machines/pauseSubscription/index.d.ts

@@ -0,0 +1,4 @@
+import { pauseSubscription } from './pauseSubscription';
+import { PauseSubscriptionEvent, SetErrorEvent, SetSubscriptionStatusEvent } from './types';
+import { pauseSubscriptionSelectors } from './selectors';
+export { PauseSubscriptionEvent, SetErrorEvent, SetSubscriptionStatusEvent, pauseSubscription, pauseSubscriptionSelectors, };

package/typings/packages/subscriptions-manager/src/machines/pauseSubscription/pauseSubscription.d.ts

@@ -0,0 +1,5 @@
+import { Events, PauseSubscriptionContext } from './types';
+export declare const pauseSubscription: import("xstate").StateMachine<PauseSubscriptionContext, any, Events, {
+    value: any;
+    context: PauseSubscriptionContext;
+}, import("xstate").BaseActionObject, import("xstate").ServiceMap, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, Events, import("xstate").BaseActionObject, import("xstate").ServiceMap>>;

package/typings/packages/subscriptions-manager/src/machines/pauseSubscription/selectors.d.ts

@@ -0,0 +1,25 @@
+import { State } from 'xstate';
+import { pauseSubscription } from './pauseSubscription';
+declare type PauseSubscriptionsMachine = typeof pauseSubscription;
+declare type PauseSubscriptionState = State<PauseSubscriptionsMachine['context']>;
+export declare const getPauseSubscriptionStatus: (machineState: PauseSubscriptionState) => {
+    idle: boolean;
+    pauseSubscriptionLoading: boolean;
+    pauseSubscriptionSuccess: boolean;
+    pauseSubscriptionError: boolean;
+};
+export declare const getErrorCode: (machineState: PauseSubscriptionState) => {
+    errorCode: string;
+};
+export declare const pauseSubscriptionSelectors: {
+    getPauseSubscriptionStatus: (machineState: PauseSubscriptionState) => {
+        idle: boolean;
+        pauseSubscriptionLoading: boolean;
+        pauseSubscriptionSuccess: boolean;
+        pauseSubscriptionError: boolean;
+    };
+    getErrorCode: (machineState: PauseSubscriptionState) => {
+        errorCode: string;
+    };
+};
+export {};

package/typings/packages/subscriptions-manager/src/machines/pauseSubscription/types.d.ts

@@ -0,0 +1,29 @@
+import { SubscriptionStatus } from '../../models';
+export declare type PauseSubscriptionContext = {
+    status: SubscriptionStatus;
+    automaticallyResumeAt: string;
+    error?: {
+        errorCode: string;
+    };
+};
+export declare type SetSubscriptionStatusEvent = {
+    type: string;
+    data: {
+        state: SubscriptionStatus;
+        automaticallyResumeAt: string;
+    };
+};
+export declare type SetErrorEvent = {
+    type: string;
+    data: {
+        errorCode: string;
+    };
+};
+export declare type PauseSubscriptionEvent = {
+    type: 'PAUSE_SUBSCRIPTION';
+    subscriptionId: number;
+    automaticallyResumeAt: Date;
+};
+export declare type Events = {
+    type: 'PAUSE_SUBSCRIPTION';
+} | PauseSubscriptionEvent | SetSubscriptionStatusEvent | SetErrorEvent;

package/typings/packages/subscriptions-manager/src/machines/paymentGateway/index.d.ts

@@ -0,0 +1,5 @@
+import { paymentGateway } from './paymentGateway';
+import { paymentGatewaySelectors } from './selectors';
+import type { PaymentGatewayInterpreter } from './types';
+export { paymentGateway, paymentGatewaySelectors };
+export type { PaymentGatewayInterpreter };

package/typings/packages/subscriptions-manager/src/machines/paymentGateway/paymentGateway.d.ts

@@ -0,0 +1,7 @@
+import { Context, GatewayConfig } from './types';
+export declare const initialContext: Context;
+declare const paymentGateway: import("xstate").StateMachine<GatewayConfig, any, import("xstate").EventObject, {
+    value: any;
+    context: GatewayConfig;
+}, import("xstate").BaseActionObject, import("xstate").ServiceMap, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, import("xstate").EventObject, import("xstate").BaseActionObject, import("xstate").ServiceMap>>;
+export { paymentGateway };

package/typings/packages/subscriptions-manager/src/machines/paymentGateway/selectors.d.ts

@@ -0,0 +1,39 @@
+import { State } from 'xstate';
+import { paymentGateway } from './paymentGateway';
+declare type PaymentGatewayMachine = typeof paymentGateway;
+declare type PaymentGatewayState = State<PaymentGatewayMachine['context']>;
+export declare const getGatewayConfig: (machineState: PaymentGatewayState) => {
+    serverHost: string;
+    securityToken: string;
+    publicKey: string;
+};
+export declare const getThreeDSecure: (machineState: PaymentGatewayState) => boolean;
+export declare const getRequiredFieldsConfig: (machineState: PaymentGatewayState) => {
+    creditCard: string[];
+    bankAccount: string[];
+};
+export declare const getVaultCurrencies: (machineState: PaymentGatewayState) => {
+    [key: string]: string[];
+};
+export declare const getDefaultVaults: (machineState: PaymentGatewayState) => {
+    creditCard: string;
+};
+export declare const paymentGatewaySelectors: {
+    getGatewayConfig: (machineState: PaymentGatewayState) => {
+        serverHost: string;
+        securityToken: string;
+        publicKey: string;
+    };
+    getThreeDSecure: (machineState: PaymentGatewayState) => boolean;
+    getVaultCurrencies: (machineState: PaymentGatewayState) => {
+        [key: string]: string[];
+    };
+    getRequiredFieldsConfig: (machineState: PaymentGatewayState) => {
+        creditCard: string[];
+        bankAccount: string[];
+    };
+    getDefaultVaults: (machineState: PaymentGatewayState) => {
+        creditCard: string;
+    };
+};
+export {};

package/typings/packages/subscriptions-manager/src/machines/paymentGateway/types.d.ts

@@ -0,0 +1,22 @@
+import { Interpreter, EventObject } from 'xstate';
+export declare type Context = GatewayConfig;
+export declare type Events = EventObject;
+export declare type GatewayConfig = {
+    serverHost: string;
+    publicKey: string | null;
+    securityToken: string | null;
+    vaultCurrencies: {
+        [key: string]: string[];
+    };
+    defaultVaults: {
+        creditCard: string | null;
+    };
+    requiredFields: {
+        creditCard: string[];
+        bankAccount: string[];
+    };
+    threeDSecure: {
+        enabled: boolean;
+    };
+};
+export declare type PaymentGatewayInterpreter = Interpreter<Context, Record<string, any>, Events>;

package/typings/packages/subscriptions-manager/src/machines/paymentProfiles/actions.d.ts

@@ -0,0 +1,4 @@
+import { Context } from './types';
+export declare const setActivePaymentProfile: import("xstate").AssignAction<Context, import("xstate").EventObject>;
+export declare const addPaymentProfile: import("xstate").AssignAction<Context, import("xstate").EventObject>;
+export declare const deletePaymentProfile: import("xstate").AssignAction<Context, import("xstate").EventObject>;

package/typings/packages/subscriptions-manager/src/machines/paymentProfiles/index.d.ts

@@ -0,0 +1,4 @@
+import { paymentProfiles } from './paymentProfiles';
+import { paymentProfilesSelectors } from './selectors';
+import { PaymentProfilesInterpreter } from './types';
+export { paymentProfiles, paymentProfilesSelectors, PaymentProfilesInterpreter, };

package/typings/packages/subscriptions-manager/src/machines/paymentProfiles/paymentProfiles.d.ts

@@ -0,0 +1,7 @@
+import { Context, Events } from './types';
+export declare const initialContext: Context;
+declare const paymentProfiles: import("xstate").StateMachine<Context, any, Events, {
+    value: any;
+    context: Context;
+}, import("xstate").BaseActionObject, import("xstate").ServiceMap, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, Events, import("xstate").BaseActionObject, import("xstate").ServiceMap>>;
+export { paymentProfiles };

package/typings/packages/subscriptions-manager/src/machines/paymentProfiles/selectors.d.ts

@@ -0,0 +1,19 @@
+import { State } from 'xstate';
+import { paymentProfiles } from './paymentProfiles';
+declare type PaymentProfilesMachine = typeof paymentProfiles;
+declare type PaymentProfilesState = State<PaymentProfilesMachine['context']>;
+export declare const getPaymentProfiles: (machineState: PaymentProfilesState) => import("../../models/paymentProfile").PaymentProfile[];
+export declare const getPaymentProfilesById: (paymentProfileId: number) => (machineState: PaymentProfilesState) => import("../../models/paymentProfile").PaymentProfile;
+export declare const getPaymentProfilesState: (machineState: PaymentProfilesState) => {
+    isLoading: boolean;
+    isError: boolean;
+};
+export declare const paymentProfilesSelectors: {
+    getPaymentProfilesState: (machineState: PaymentProfilesState) => {
+        isLoading: boolean;
+        isError: boolean;
+    };
+    getPaymentProfilesById: (paymentProfileId: number) => (machineState: PaymentProfilesState) => import("../../models/paymentProfile").PaymentProfile;
+    getPaymentProfiles: (machineState: PaymentProfilesState) => import("../../models/paymentProfile").PaymentProfile[];
+};
+export {};

package/typings/packages/subscriptions-manager/src/machines/paymentProfiles/serializers.d.ts

@@ -0,0 +1,12 @@
+import { PaymentProfile, PaymentProfileStatus } from '../../models/paymentProfile';
+export declare const serializePaymentProfiles: (items: PaymentProfile[], vaultCurrencies: Record<string, string[]>, subscriptionCurrency: string, subscriptionPaymentProfileId: number) => {
+    status: PaymentProfileStatus;
+    id: number;
+    expired?: boolean;
+    type: import("../../models/paymentProfile").PaymentProfileType;
+    requiredFields: string[];
+    vault: string;
+    bankAccount?: import("../../models/paymentProfile").BankAccount;
+    creditCard?: import("../../models/paymentProfile").CreditCard;
+    address?: import("../../models/paymentProfile/types").Address;
+}[];

package/typings/packages/subscriptions-manager/src/machines/paymentProfiles/types.d.ts

@@ -0,0 +1,30 @@
+import { Interpreter } from 'xstate';
+import { PaymentProfile } from '../../models/paymentProfile';
+export declare type Context = {
+    subscriptionCurrency: string;
+    vaultCurrencies: Record<string, string[]>;
+    paymentProfiles: PaymentProfile[];
+    subscriptionPaymentProfileId: number;
+    error: null;
+};
+export declare type Events = InitializeEvent | AddPaymentProfileEvent | ChangePaymentProfileEvent | RetryFetchEvent | DeletePaymentProfileEvent;
+export declare type InitializeEvent = {
+    type: 'INITIALIZE';
+};
+export declare type RetryFetchEvent = {
+    type: 'RETRY_FETCH';
+};
+export declare type DeletePaymentProfileEvent = {
+    type: 'DELETE_PAYMENT_PROFILE';
+    paymentProfileId: number;
+};
+export declare type AddPaymentProfileEvent = {
+    type: 'ADD_PAYMENT_PROFILE';
+    paymentProfile: PaymentProfile;
+    paymentProfileId: PaymentProfile['id'];
+};
+export declare type ChangePaymentProfileEvent = {
+    type: 'CHANGE_PAYMENT_PROFILE';
+    paymentProfileId: PaymentProfile['id'];
+};
+export declare type PaymentProfilesInterpreter = Interpreter<Context, Record<string, any>, Events>;

package/typings/packages/subscriptions-manager/src/machines/productCatalog/actions.d.ts

@@ -0,0 +1,3 @@
+export declare const setCatalogExpandState: import("xstate").AssignAction<{
+    expandedCatalogItems: number[];
+}, import("xstate").EventObject>;

package/typings/packages/subscriptions-manager/src/machines/productCatalog/index.d.ts

@@ -0,0 +1,5 @@
+import { productCatalog } from './productCatalog';
+import { productCatalogSelectors } from './selectors';
+import type { ProductCatalogInterpreter } from './types';
+export { productCatalog, productCatalogSelectors };
+export type { ProductCatalogInterpreter };

package/typings/packages/subscriptions-manager/src/machines/productCatalog/productCatalog.d.ts

@@ -0,0 +1,6 @@
+import { Context, Events } from './types';
+declare const productCatalog: import("xstate").StateMachine<Context, any, Events, {
+    value: any;
+    context: Context;
+}, import("xstate").BaseActionObject, import("xstate").ServiceMap, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, Events, import("xstate").BaseActionObject, import("xstate").ServiceMap>>;
+export { productCatalog };

package/typings/packages/subscriptions-manager/src/machines/productCatalog/selectors.d.ts

@@ -0,0 +1,23 @@
+import { State } from 'xstate';
+import { productCatalog } from './productCatalog';
+declare type ProductCatalogMachine = typeof productCatalog;
+declare type ProductCatalogState = State<ProductCatalogMachine['context']>;
+export declare const getProductCatalogItems: (machineState: ProductCatalogState) => import("./types").ProductFamily[];
+export declare const getProductCatalogById: (catalogId: number) => (machineState: ProductCatalogState) => import("./types").ProductFamily;
+export declare const getProductCatalogFetchStatus: (machineState: ProductCatalogState) => {
+    isLoading: boolean;
+    error: boolean;
+    ready: boolean;
+};
+export declare const getExpandedCatalogItems: (machineState: ProductCatalogState) => number[];
+export declare const productCatalogSelectors: {
+    getExpandedCatalogItems: (machineState: ProductCatalogState) => number[];
+    getProductCatalogById: (catalogId: number) => (machineState: ProductCatalogState) => import("./types").ProductFamily;
+    getProductCatalogItems: (machineState: ProductCatalogState) => import("./types").ProductFamily[];
+    getProductCatalogFetchStatus: (machineState: ProductCatalogState) => {
+        isLoading: boolean;
+        error: boolean;
+        ready: boolean;
+    };
+};
+export {};

package/typings/packages/subscriptions-manager/src/machines/productCatalog/types.d.ts

@@ -0,0 +1,20 @@
+import { Interpreter } from 'xstate';
+export declare type Context = {
+    items: ProductFamily[];
+    expandedCatalogItems: number[];
+};
+export declare type SetExpandStateEvent = {
+    type: 'SET_CATALOG_EXPAND';
+    catalogId: number;
+    isExpanded: boolean;
+};
+export declare type Events = {
+    type: 'INITIALIZE';
+} | {
+    type: 'RETRY_FETCH_PRODUCT_CATALOG';
+} | SetExpandStateEvent;
+export declare type ProductFamily = {
+    id: number;
+    name: string;
+};
+export declare type ProductCatalogInterpreter = Interpreter<Context, Record<string, any>, Events>;

package/typings/packages/subscriptions-manager/src/machines/reactivateSubscription/index.d.ts

@@ -0,0 +1,4 @@
+import { ReactivateSubscriptionEvent, SetErrorEvent } from './types';
+import { reactivateSubscriptionSelectors } from './selectors';
+import { reactivateSubscription } from './reactivateSubscription';
+export { ReactivateSubscriptionEvent, SetErrorEvent, reactivateSubscription, reactivateSubscriptionSelectors, };

package/typings/packages/subscriptions-manager/src/machines/reactivateSubscription/reactivateSubscription.d.ts

@@ -0,0 +1,5 @@
+import { Events, ReactivateSubscriptionContext } from './types';
+export declare const reactivateSubscription: import("xstate").StateMachine<ReactivateSubscriptionContext, any, Events, {
+    value: any;
+    context: ReactivateSubscriptionContext;
+}, import("xstate").BaseActionObject, import("xstate").ServiceMap, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, Events, import("xstate").BaseActionObject, import("xstate").ServiceMap>>;

package/typings/packages/subscriptions-manager/src/machines/reactivateSubscription/selectors.d.ts

@@ -0,0 +1,31 @@
+import { State } from 'xstate';
+import { reactivateSubscription } from './reactivateSubscription';
+declare type ReactivateSubscriptionMachine = typeof reactivateSubscription;
+declare type ReactivateSubscriptionState = State<ReactivateSubscriptionMachine['context']>;
+export declare const getReactivateSubscriptionStatus: (machineState: ReactivateSubscriptionState) => {
+    idle: boolean;
+    reactivateSubscriptionLoading: boolean;
+    reactivateSubscriptionSuccess: boolean;
+    reactivateSubscriptionError: boolean;
+};
+export declare const getErrorCode: (machineState: import("xstate").StateMachine<import("./types").ReactivateSubscriptionContext, any, import("./types").Events, {
+    value: any;
+    context: import("./types").ReactivateSubscriptionContext;
+}, import("xstate").BaseActionObject, import("xstate").ServiceMap, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, import("./types").Events, import("xstate").BaseActionObject, import("xstate").ServiceMap>>) => {
+    errorCode: string;
+};
+export declare const reactivateSubscriptionSelectors: {
+    getReactivateSubscriptionStatus: (machineState: ReactivateSubscriptionState) => {
+        idle: boolean;
+        reactivateSubscriptionLoading: boolean;
+        reactivateSubscriptionSuccess: boolean;
+        reactivateSubscriptionError: boolean;
+    };
+    getErrorCode: (machineState: import("xstate").StateMachine<import("./types").ReactivateSubscriptionContext, any, import("./types").Events, {
+        value: any;
+        context: import("./types").ReactivateSubscriptionContext;
+    }, import("xstate").BaseActionObject, import("xstate").ServiceMap, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, import("./types").Events, import("xstate").BaseActionObject, import("xstate").ServiceMap>>) => {
+        errorCode: string;
+    };
+};
+export {};

package/typings/packages/subscriptions-manager/src/machines/reactivateSubscription/types.d.ts

@@ -0,0 +1,23 @@
+export declare type ReactivateSubscriptionContext = {
+    error?: {
+        errorCode: string;
+    };
+};
+export declare type SetErrorEvent = {
+    type: string;
+    data: {
+        errorCode: string;
+    };
+};
+export declare type ReactivateSubscriptionEvent = {
+    type: 'REACTIVATE_SUBSCRIPTION';
+};
+export declare type ReactivateSubscriptionDoneEvent = {
+    type: 'REACTIVATE_SUBSCRIPTION_DONE';
+    data: {
+        currentBillingAmountInCents: number;
+        currentPeriodEndsAt: string;
+        nextAssessmentAt: string;
+    };
+};
+export declare type Events = ReactivateSubscriptionEvent | SetErrorEvent | ReactivateSubscriptionDoneEvent;

package/typings/packages/subscriptions-manager/src/machines/resumeSubscription/index.d.ts

@@ -0,0 +1,4 @@
+import { resumeSubscription } from './resumeSubscription';
+import { resumeSubscriptionSelectors } from './selectors';
+import type { ResumeSubscriptionAtEvent, SetErrorEvent, SetSubscriptionAutoResumptionDateEvent } from './types';
+export { resumeSubscriptionSelectors, resumeSubscription, ResumeSubscriptionAtEvent, SetErrorEvent, SetSubscriptionAutoResumptionDateEvent, };