@powerhousedao/service-offering 0.0.1

package/dist/document-models/subscription-instance/src/reducers/service.js

@@ -0,0 +1,110 @@
+export const subscriptionInstanceServiceOperations = {
+    addServiceOperation(state, action) {
+        const { input } = action;
+        let setupCost = null;
+        if (input.setupAmount && input.setupCurrency) {
+            setupCost = {
+                amount: input.setupAmount,
+                currency: input.setupCurrency,
+                billingDate: input.setupBillingDate || null,
+                paymentDate: input.setupPaymentDate || null,
+            };
+        }
+        let recurringCost = null;
+        if (input.recurringAmount &&
+            input.recurringCurrency &&
+            input.recurringBillingCycle) {
+            recurringCost = {
+                amount: input.recurringAmount,
+                currency: input.recurringCurrency,
+                billingCycle: input.recurringBillingCycle,
+                nextBillingDate: input.recurringNextBillingDate || null,
+                lastPaymentDate: input.recurringLastPaymentDate || null,
+            };
+        }
+        state.services.push({
+            id: input.serviceId,
+            name: input.name || null,
+            description: input.description || null,
+            setupCost,
+            recurringCost,
+            metrics: [],
+        });
+    },
+    removeServiceOperation(state, action) {
+        const index = state.services.findIndex((s) => s.id === action.input.serviceId);
+        if (index !== -1) {
+            state.services.splice(index, 1);
+        }
+    },
+    updateServiceSetupCostOperation(state, action) {
+        const { input } = action;
+        const service = state.services.find((s) => s.id === input.serviceId);
+        if (service) {
+            if (input.amount !== undefined &&
+                input.amount !== null &&
+                input.currency) {
+                service.setupCost = {
+                    amount: input.amount,
+                    currency: input.currency,
+                    billingDate: input.billingDate || null,
+                    paymentDate: input.paymentDate || null,
+                };
+            }
+            else if (service.setupCost) {
+                if (input.billingDate)
+                    service.setupCost.billingDate = input.billingDate;
+                if (input.paymentDate)
+                    service.setupCost.paymentDate = input.paymentDate;
+            }
+        }
+    },
+    updateServiceRecurringCostOperation(state, action) {
+        const { input } = action;
+        const service = state.services.find((s) => s.id === input.serviceId);
+        if (service) {
+            if (input.amount !== undefined &&
+                input.amount !== null &&
+                input.currency &&
+                input.billingCycle) {
+                service.recurringCost = {
+                    amount: input.amount,
+                    currency: input.currency,
+                    billingCycle: input.billingCycle,
+                    nextBillingDate: input.nextBillingDate || null,
+                    lastPaymentDate: input.lastPaymentDate || null,
+                };
+            }
+            else if (service.recurringCost) {
+                if (input.nextBillingDate)
+                    service.recurringCost.nextBillingDate = input.nextBillingDate;
+                if (input.lastPaymentDate)
+                    service.recurringCost.lastPaymentDate = input.lastPaymentDate;
+            }
+        }
+    },
+    reportSetupPaymentOperation(state, action) {
+        const { input } = action;
+        const service = state.services.find((s) => s.id === input.serviceId);
+        if (service && service.setupCost) {
+            service.setupCost.paymentDate = input.paymentDate;
+        }
+    },
+    reportRecurringPaymentOperation(state, action) {
+        const { input } = action;
+        const service = state.services.find((s) => s.id === input.serviceId);
+        if (service && service.recurringCost) {
+            service.recurringCost.lastPaymentDate = input.paymentDate;
+        }
+    },
+    updateServiceInfoOperation(state, action) {
+        const { input } = action;
+        const service = state.services.find((s) => s.id === input.serviceId);
+        if (service) {
+            if (input.name)
+                service.name = input.name;
+            if (input.description)
+                service.description = input.description;
+        }
+    },
+};

package/dist/document-models/subscription-instance/src/reducers/subscription.d.ts

@@ -0,0 +1,3 @@
+import type { SubscriptionInstanceSubscriptionOperations } from "@powerhousedao/service-offering/document-models/subscription-instance";
+export declare const subscriptionInstanceSubscriptionOperations: SubscriptionInstanceSubscriptionOperations;
+//# sourceMappingURL=subscription.d.ts.map

package/dist/document-models/subscription-instance/src/reducers/subscription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscription.d.ts","sourceRoot":"","sources":["../../../../../document-models/subscription-instance/src/reducers/subscription.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0CAA0C,EAAE,MAAM,uEAAuE,CAAC;AAExI,eAAO,MAAM,0CAA0C,EAAE,0CAwHtD,CAAC"}

package/dist/document-models/subscription-instance/src/reducers/subscription.js

@@ -0,0 +1,107 @@
+export const subscriptionInstanceSubscriptionOperations = {
+    initializeSubscriptionOperation(state, action) {
+        const { input } = action;
+        state.customerId = input.customerId || null;
+        state.customerName = input.customerName || null;
+        state.customerEmail = input.customerEmail || null;
+        state.serviceOfferingId = input.serviceOfferingId || null;
+        state.tierName = input.tierName || null;
+        state.tierPricingOptionId = input.tierPricingOptionId || null;
+        state.autoRenew = input.autoRenew ?? false;
+        state.createdAt = input.createdAt;
+        state.status = "PENDING";
+        if (input.resourceId) {
+            state.resource = {
+                id: input.resourceId,
+                label: input.resourceLabel || null,
+                thumbnailUrl: input.resourceThumbnailUrl || null,
+            };
+        }
+    },
+    setResourceDocumentOperation(state, action) {
+        const { input } = action;
+        state.resource = {
+            id: input.resourceId,
+            label: input.resourceLabel || null,
+            thumbnailUrl: input.resourceThumbnailUrl || null,
+        };
+    },
+    updateSubscriptionStatusOperation(state, action) {
+        state.status = action.input.status;
+    },
+    activateSubscriptionOperation(state, action) {
+        state.status = "ACTIVE";
+        state.activatedSince = action.input.activatedSince;
+        state.pausedSince = null;
+        state.expiringSince = null;
+    },
+    pauseSubscriptionOperation(state, action) {
+        state.status = "PAUSED";
+        state.pausedSince = action.input.pausedSince;
+    },
+    setExpiringOperation(state, action) {
+        state.status = "EXPIRING";
+        state.expiringSince = action.input.expiringSince;
+    },
+    cancelSubscriptionOperation(state, action) {
+        state.status = "CANCELLED";
+        state.cancelledSince = action.input.cancelledSince;
+        state.cancellationReason = action.input.cancellationReason || null;
+    },
+    resumeSubscriptionOperation(state, _action) {
+        state.status = "ACTIVE";
+        state.pausedSince = null;
+    },
+    renewExpiringSubscriptionOperation(state, action) {
+        state.status = "ACTIVE";
+        state.expiringSince = null;
+        if (action.input.newRenewalDate) {
+            state.renewalDate = action.input.newRenewalDate;
+        }
+    },
+    setBudgetCategoryOperation(state, action) {
+        state.budget = {
+            id: action.input.budgetId,
+            label: action.input.budgetLabel,
+        };
+    },
+    removeBudgetCategoryOperation(state, _action) {
+        state.budget = null;
+    },
+    updateCustomerInfoOperation(state, action) {
+        const { input } = action;
+        if (input.customerId)
+            state.customerId = input.customerId;
+        if (input.customerName)
+            state.customerName = input.customerName;
+        if (input.customerEmail)
+            state.customerEmail = input.customerEmail;
+    },
+    updateTierInfoOperation(state, action) {
+        const { input } = action;
+        if (input.tierName)
+            state.tierName = input.tierName;
+        if (input.tierPricingOptionId)
+            state.tierPricingOptionId = input.tierPricingOptionId;
+    },
+    setOperatorNotesOperation(state, action) {
+        state.operatorNotes = action.input.operatorNotes || null;
+    },
+    setAutoRenewOperation(state, action) {
+        state.autoRenew = action.input.autoRenew;
+    },
+    setRenewalDateOperation(state, action) {
+        state.renewalDate = action.input.renewalDate;
+    },
+    updateBillingProjectionOperation(state, action) {
+        if (action.input.nextBillingDate) {
+            state.nextBillingDate = action.input.nextBillingDate;
+        }
+        if (action.input.projectedBillAmount !== undefined) {
+            state.projectedBillAmount = action.input.projectedBillAmount ?? null;
+        }
+        if (action.input.projectedBillCurrency) {
+            state.projectedBillCurrency = action.input.projectedBillCurrency;
+        }
+    },
+};

package/dist/document-models/subscription-instance/src/utils.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/document-models/subscription-instance/src/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../document-models/subscription-instance/src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC"}

package/dist/document-models/subscription-instance/src/utils.js

@@ -0,0 +1 @@
+export {};

package/dist/document-models/subscription-instance/tests/billing.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=billing.test.d.ts.map

package/dist/document-models/subscription-instance/tests/billing.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"billing.test.d.ts","sourceRoot":"","sources":["../../../../document-models/subscription-instance/tests/billing.test.ts"],"names":[],"mappings":""}

package/dist/document-models/subscription-instance/tests/billing.test.js

@@ -0,0 +1,17 @@
+import { generateMock } from "@powerhousedao/codegen";
+import { describe, expect, it } from "vitest";
+import { reducer, utils, isSubscriptionInstanceDocument, updateBillingProjection, UpdateBillingProjectionInputSchema, } from "@powerhousedao/service-offering/document-models/subscription-instance";
+// Billing module (invoices) has been removed.
+// Billing projection is now handled by the subscription module.
+describe("BillingProjection", () => {
+    it("should handle updateBillingProjection operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(UpdateBillingProjectionInputSchema());
+        const updatedDocument = reducer(document, updateBillingProjection(input));
+        expect(isSubscriptionInstanceDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_BILLING_PROJECTION");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+});

package/dist/document-models/subscription-instance/tests/customer.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=customer.test.d.ts.map

package/dist/document-models/subscription-instance/tests/customer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customer.test.d.ts","sourceRoot":"","sources":["../../../../document-models/subscription-instance/tests/customer.test.ts"],"names":[],"mappings":""}

package/dist/document-models/subscription-instance/tests/customer.test.js

@@ -0,0 +1,26 @@
+import { generateMock } from "@powerhousedao/codegen";
+import { describe, expect, it } from "vitest";
+import { reducer, utils, isSubscriptionInstanceDocument, setCustomerType, updateTeamMemberCount, SetCustomerTypeInputSchema, UpdateTeamMemberCountInputSchema, } from "@powerhousedao/service-offering/document-models/subscription-instance";
+// Communication channels, wallet, and KYC operations have been removed.
+describe("CustomerOperations", () => {
+    it("should handle setCustomerType operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(SetCustomerTypeInputSchema());
+        const updatedDocument = reducer(document, setCustomerType(input));
+        expect(isSubscriptionInstanceDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("SET_CUSTOMER_TYPE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle updateTeamMemberCount operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(UpdateTeamMemberCountInputSchema());
+        const updatedDocument = reducer(document, updateTeamMemberCount(input));
+        expect(isSubscriptionInstanceDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_TEAM_MEMBER_COUNT");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+});

package/dist/document-models/subscription-instance/tests/document-model.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+export {};
+//# sourceMappingURL=document-model.test.d.ts.map

package/dist/document-models/subscription-instance/tests/document-model.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-model.test.d.ts","sourceRoot":"","sources":["../../../../document-models/subscription-instance/tests/document-model.test.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH;;;GAGG"}

package/dist/document-models/subscription-instance/tests/document-model.test.js

@@ -0,0 +1,104 @@
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+import { describe, it, expect } from "vitest";
+import { utils, initialGlobalState, initialLocalState, subscriptionInstanceDocumentType, isSubscriptionInstanceDocument, assertIsSubscriptionInstanceDocument, isSubscriptionInstanceState, assertIsSubscriptionInstanceState, } from "@powerhousedao/service-offering/document-models/subscription-instance";
+import { ZodError } from "zod";
+describe("SubscriptionInstance Document Model", () => {
+    it("should create a new SubscriptionInstance document", () => {
+        const document = utils.createDocument();
+        expect(document).toBeDefined();
+        expect(document.header.documentType).toBe(subscriptionInstanceDocumentType);
+    });
+    it("should create a new SubscriptionInstance document with a valid initial state", () => {
+        const document = utils.createDocument();
+        expect(document.state.global).toStrictEqual(initialGlobalState);
+        expect(document.state.local).toStrictEqual(initialLocalState);
+        expect(isSubscriptionInstanceDocument(document)).toBe(true);
+        expect(isSubscriptionInstanceState(document.state)).toBe(true);
+    });
+    it("should reject a document that is not a SubscriptionInstance document", () => {
+        const wrongDocumentType = utils.createDocument();
+        wrongDocumentType.header.documentType = "the-wrong-thing-1234";
+        try {
+            expect(assertIsSubscriptionInstanceDocument(wrongDocumentType)).toThrow();
+            expect(isSubscriptionInstanceDocument(wrongDocumentType)).toBe(false);
+        }
+        catch (error) {
+            expect(error).toBeInstanceOf(ZodError);
+        }
+    });
+    const wrongState = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    wrongState.state.global = {
+        ...{ notWhat: "you want" },
+    };
+    try {
+        expect(isSubscriptionInstanceState(wrongState.state)).toBe(false);
+        expect(assertIsSubscriptionInstanceState(wrongState.state)).toThrow();
+        expect(isSubscriptionInstanceDocument(wrongState)).toBe(false);
+        expect(assertIsSubscriptionInstanceDocument(wrongState)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+    const wrongInitialState = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    wrongInitialState.initialState.global = {
+        ...{ notWhat: "you want" },
+    };
+    try {
+        expect(isSubscriptionInstanceState(wrongInitialState.state)).toBe(false);
+        expect(assertIsSubscriptionInstanceState(wrongInitialState.state)).toThrow();
+        expect(isSubscriptionInstanceDocument(wrongInitialState)).toBe(false);
+        expect(assertIsSubscriptionInstanceDocument(wrongInitialState)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+    const missingIdInHeader = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    delete missingIdInHeader.header.id;
+    try {
+        expect(isSubscriptionInstanceDocument(missingIdInHeader)).toBe(false);
+        expect(assertIsSubscriptionInstanceDocument(missingIdInHeader)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+    const missingNameInHeader = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    delete missingNameInHeader.header.name;
+    try {
+        expect(isSubscriptionInstanceDocument(missingNameInHeader)).toBe(false);
+        expect(assertIsSubscriptionInstanceDocument(missingNameInHeader)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+    const missingCreatedAtUtcIsoInHeader = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    delete missingCreatedAtUtcIsoInHeader.header.createdAtUtcIso;
+    try {
+        expect(isSubscriptionInstanceDocument(missingCreatedAtUtcIsoInHeader)).toBe(false);
+        expect(assertIsSubscriptionInstanceDocument(missingCreatedAtUtcIsoInHeader)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+    const missingLastModifiedAtUtcIsoInHeader = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    delete missingLastModifiedAtUtcIsoInHeader.header.lastModifiedAtUtcIso;
+    try {
+        expect(isSubscriptionInstanceDocument(missingLastModifiedAtUtcIsoInHeader)).toBe(false);
+        expect(assertIsSubscriptionInstanceDocument(missingLastModifiedAtUtcIsoInHeader)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+});

package/dist/document-models/subscription-instance/tests/metrics.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=metrics.test.d.ts.map

package/dist/document-models/subscription-instance/tests/metrics.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.test.d.ts","sourceRoot":"","sources":["../../../../document-models/subscription-instance/tests/metrics.test.ts"],"names":[],"mappings":""}

package/dist/document-models/subscription-instance/tests/metrics.test.js

@@ -0,0 +1,65 @@
+import { generateMock } from "@powerhousedao/codegen";
+import { describe, expect, it } from "vitest";
+import { reducer, utils, isSubscriptionInstanceDocument, addServiceMetric, updateMetric, updateMetricUsage, removeServiceMetric, incrementMetricUsage, decrementMetricUsage, AddServiceMetricInputSchema, UpdateMetricInputSchema, UpdateMetricUsageInputSchema, RemoveServiceMetricInputSchema, IncrementMetricUsageInputSchema, DecrementMetricUsageInputSchema, } from "@powerhousedao/service-offering/document-models/subscription-instance";
+describe("MetricsOperations", () => {
+    it("should handle addServiceMetric operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(AddServiceMetricInputSchema());
+        const updatedDocument = reducer(document, addServiceMetric(input));
+        expect(isSubscriptionInstanceDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("ADD_SERVICE_METRIC");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle updateMetric operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(UpdateMetricInputSchema());
+        const updatedDocument = reducer(document, updateMetric(input));
+        expect(isSubscriptionInstanceDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_METRIC");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle updateMetricUsage operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(UpdateMetricUsageInputSchema());
+        const updatedDocument = reducer(document, updateMetricUsage(input));
+        expect(isSubscriptionInstanceDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_METRIC_USAGE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle removeServiceMetric operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(RemoveServiceMetricInputSchema());
+        const updatedDocument = reducer(document, removeServiceMetric(input));
+        expect(isSubscriptionInstanceDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("REMOVE_SERVICE_METRIC");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle incrementMetricUsage operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(IncrementMetricUsageInputSchema());
+        const updatedDocument = reducer(document, incrementMetricUsage(input));
+        expect(isSubscriptionInstanceDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("INCREMENT_METRIC_USAGE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle decrementMetricUsage operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(DecrementMetricUsageInputSchema());
+        const updatedDocument = reducer(document, decrementMetricUsage(input));
+        expect(isSubscriptionInstanceDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("DECREMENT_METRIC_USAGE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+});

package/dist/document-models/subscription-instance/tests/requests.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=requests.test.d.ts.map

package/dist/document-models/subscription-instance/tests/requests.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requests.test.d.ts","sourceRoot":"","sources":["../../../../document-models/subscription-instance/tests/requests.test.ts"],"names":[],"mappings":""}

package/dist/document-models/subscription-instance/tests/requests.test.js

@@ -0,0 +1,8 @@
+import { describe, it } from "vitest";
+// Note: The requests module has been removed from SubscriptionInstance.
+// These tests are stubbed out until the module is re-implemented.
+describe("RequestsOperations", () => {
+    it.skip("requests module has been removed", () => {
+        // Tests skipped - requests module no longer exists
+    });
+});

package/dist/document-models/subscription-instance/tests/service-group.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=service-group.test.d.ts.map

package/dist/document-models/subscription-instance/tests/service-group.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-group.test.d.ts","sourceRoot":"","sources":["../../../../document-models/subscription-instance/tests/service-group.test.ts"],"names":[],"mappings":""}

package/dist/document-models/subscription-instance/tests/service-group.test.js

@@ -0,0 +1,45 @@
+import { generateMock } from "@powerhousedao/codegen";
+import { describe, expect, it } from "vitest";
+import { reducer, utils, isSubscriptionInstanceDocument, addServiceGroup, removeServiceGroup, addServiceToGroup, removeServiceFromGroup, AddServiceGroupInputSchema, RemoveServiceGroupInputSchema, AddServiceToGroupInputSchema, RemoveServiceFromGroupInputSchema, } from "@powerhousedao/service-offering/document-models/subscription-instance";
+describe("ServiceGroupOperations", () => {
+    it("should handle addServiceGroup operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(AddServiceGroupInputSchema());
+        const updatedDocument = reducer(document, addServiceGroup(input));
+        expect(isSubscriptionInstanceDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("ADD_SERVICE_GROUP");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle removeServiceGroup operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(RemoveServiceGroupInputSchema());
+        const updatedDocument = reducer(document, removeServiceGroup(input));
+        expect(isSubscriptionInstanceDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("REMOVE_SERVICE_GROUP");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle addServiceToGroup operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(AddServiceToGroupInputSchema());
+        const updatedDocument = reducer(document, addServiceToGroup(input));
+        expect(isSubscriptionInstanceDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("ADD_SERVICE_TO_GROUP");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle removeServiceFromGroup operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(RemoveServiceFromGroupInputSchema());
+        const updatedDocument = reducer(document, removeServiceFromGroup(input));
+        expect(isSubscriptionInstanceDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("REMOVE_SERVICE_FROM_GROUP");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+});

package/dist/document-models/subscription-instance/tests/service.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=service.test.d.ts.map

package/dist/document-models/subscription-instance/tests/service.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.test.d.ts","sourceRoot":"","sources":["../../../../document-models/subscription-instance/tests/service.test.ts"],"names":[],"mappings":""}

package/dist/document-models/subscription-instance/tests/service.test.js

@@ -0,0 +1,75 @@
+import { generateMock } from "@powerhousedao/codegen";
+import { describe, expect, it } from "vitest";
+import { reducer, utils, isSubscriptionInstanceDocument, addService, removeService, updateServiceSetupCost, updateServiceRecurringCost, reportSetupPayment, reportRecurringPayment, updateServiceInfo, AddServiceInputSchema, RemoveServiceInputSchema, UpdateServiceSetupCostInputSchema, UpdateServiceRecurringCostInputSchema, ReportSetupPaymentInputSchema, ReportRecurringPaymentInputSchema, UpdateServiceInfoInputSchema, } from "@powerhousedao/service-offering/document-models/subscription-instance";
+describe("ServiceOperations", () => {
+    it("should handle addService operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(AddServiceInputSchema());
+        const updatedDocument = reducer(document, addService(input));
+        expect(isSubscriptionInstanceDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("ADD_SERVICE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle removeService operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(RemoveServiceInputSchema());
+        const updatedDocument = reducer(document, removeService(input));
+        expect(isSubscriptionInstanceDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("REMOVE_SERVICE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle updateServiceSetupCost operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(UpdateServiceSetupCostInputSchema());
+        const updatedDocument = reducer(document, updateServiceSetupCost(input));
+        expect(isSubscriptionInstanceDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_SERVICE_SETUP_COST");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle updateServiceRecurringCost operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(UpdateServiceRecurringCostInputSchema());
+        const updatedDocument = reducer(document, updateServiceRecurringCost(input));
+        expect(isSubscriptionInstanceDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_SERVICE_RECURRING_COST");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle reportSetupPayment operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(ReportSetupPaymentInputSchema());
+        const updatedDocument = reducer(document, reportSetupPayment(input));
+        expect(isSubscriptionInstanceDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("REPORT_SETUP_PAYMENT");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle reportRecurringPayment operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(ReportRecurringPaymentInputSchema());
+        const updatedDocument = reducer(document, reportRecurringPayment(input));
+        expect(isSubscriptionInstanceDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("REPORT_RECURRING_PAYMENT");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle updateServiceInfo operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(UpdateServiceInfoInputSchema());
+        const updatedDocument = reducer(document, updateServiceInfo(input));
+        expect(isSubscriptionInstanceDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_SERVICE_INFO");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+});