@powerhousedao/service-offering 0.0.1

package/dist/document-models/service-offering/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/service-offering/tests/document-model.test.d.ts.map

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

package/dist/document-models/service-offering/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, serviceOfferingDocumentType, isServiceOfferingDocument, assertIsServiceOfferingDocument, isServiceOfferingState, assertIsServiceOfferingState, } from "@powerhousedao/service-offering/document-models/service-offering";
+import { ZodError } from "zod";
+describe("ServiceOffering Document Model", () => {
+    it("should create a new ServiceOffering document", () => {
+        const document = utils.createDocument();
+        expect(document).toBeDefined();
+        expect(document.header.documentType).toBe(serviceOfferingDocumentType);
+    });
+    it("should create a new ServiceOffering document with a valid initial state", () => {
+        const document = utils.createDocument();
+        expect(document.state.global).toStrictEqual(initialGlobalState);
+        expect(document.state.local).toStrictEqual(initialLocalState);
+        expect(isServiceOfferingDocument(document)).toBe(true);
+        expect(isServiceOfferingState(document.state)).toBe(true);
+    });
+    it("should reject a document that is not a ServiceOffering document", () => {
+        const wrongDocumentType = utils.createDocument();
+        wrongDocumentType.header.documentType = "the-wrong-thing-1234";
+        try {
+            expect(assertIsServiceOfferingDocument(wrongDocumentType)).toThrow();
+            expect(isServiceOfferingDocument(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(isServiceOfferingState(wrongState.state)).toBe(false);
+        expect(assertIsServiceOfferingState(wrongState.state)).toThrow();
+        expect(isServiceOfferingDocument(wrongState)).toBe(false);
+        expect(assertIsServiceOfferingDocument(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(isServiceOfferingState(wrongInitialState.state)).toBe(false);
+        expect(assertIsServiceOfferingState(wrongInitialState.state)).toThrow();
+        expect(isServiceOfferingDocument(wrongInitialState)).toBe(false);
+        expect(assertIsServiceOfferingDocument(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(isServiceOfferingDocument(missingIdInHeader)).toBe(false);
+        expect(assertIsServiceOfferingDocument(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(isServiceOfferingDocument(missingNameInHeader)).toBe(false);
+        expect(assertIsServiceOfferingDocument(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(isServiceOfferingDocument(missingCreatedAtUtcIsoInHeader)).toBe(false);
+        expect(assertIsServiceOfferingDocument(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(isServiceOfferingDocument(missingLastModifiedAtUtcIsoInHeader)).toBe(false);
+        expect(assertIsServiceOfferingDocument(missingLastModifiedAtUtcIsoInHeader)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+});

package/dist/document-models/service-offering/tests/offering-management.test.d.ts

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

package/dist/document-models/service-offering/tests/offering-management.test.d.ts.map

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

package/dist/document-models/service-offering/tests/offering-management.test.js

@@ -0,0 +1,125 @@
+import { generateMock } from "@powerhousedao/codegen";
+import { describe, expect, it } from "vitest";
+import { reducer, utils, isServiceOfferingDocument, updateOfferingInfo, updateOfferingStatus, setOperator, setOfferingId, addTargetAudience, removeTargetAudience, setFacetTarget, removeFacetTarget, addFacetOption, removeFacetOption, selectResourceTemplate, changeResourceTemplate, UpdateOfferingInfoInputSchema, UpdateOfferingStatusInputSchema, SetOperatorInputSchema, SetOfferingIdInputSchema, AddTargetAudienceInputSchema, RemoveTargetAudienceInputSchema, SetFacetTargetInputSchema, RemoveFacetTargetInputSchema, AddFacetOptionInputSchema, RemoveFacetOptionInputSchema, SelectResourceTemplateInputSchema, ChangeResourceTemplateInputSchema, } from "@powerhousedao/service-offering/document-models/service-offering";
+describe("OfferingManagementOperations", () => {
+    it("should handle updateOfferingInfo operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(UpdateOfferingInfoInputSchema());
+        const updatedDocument = reducer(document, updateOfferingInfo(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_OFFERING_INFO");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle updateOfferingStatus operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(UpdateOfferingStatusInputSchema());
+        const updatedDocument = reducer(document, updateOfferingStatus(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_OFFERING_STATUS");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle setOperator operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(SetOperatorInputSchema());
+        const updatedDocument = reducer(document, setOperator(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("SET_OPERATOR");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle setOfferingId operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(SetOfferingIdInputSchema());
+        const updatedDocument = reducer(document, setOfferingId(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("SET_OFFERING_ID");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle addTargetAudience operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(AddTargetAudienceInputSchema());
+        const updatedDocument = reducer(document, addTargetAudience(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("ADD_TARGET_AUDIENCE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle removeTargetAudience operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(RemoveTargetAudienceInputSchema());
+        const updatedDocument = reducer(document, removeTargetAudience(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("REMOVE_TARGET_AUDIENCE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle setFacetTarget operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(SetFacetTargetInputSchema());
+        const updatedDocument = reducer(document, setFacetTarget(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("SET_FACET_TARGET");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle removeFacetTarget operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(RemoveFacetTargetInputSchema());
+        const updatedDocument = reducer(document, removeFacetTarget(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("REMOVE_FACET_TARGET");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle addFacetOption operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(AddFacetOptionInputSchema());
+        const updatedDocument = reducer(document, addFacetOption(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("ADD_FACET_OPTION");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle removeFacetOption operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(RemoveFacetOptionInputSchema());
+        const updatedDocument = reducer(document, removeFacetOption(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("REMOVE_FACET_OPTION");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle selectResourceTemplate operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(SelectResourceTemplateInputSchema());
+        const updatedDocument = reducer(document, selectResourceTemplate(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("SELECT_RESOURCE_TEMPLATE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle changeResourceTemplate operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(ChangeResourceTemplateInputSchema());
+        const updatedDocument = reducer(document, changeResourceTemplate(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("CHANGE_RESOURCE_TEMPLATE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+});

package/dist/document-models/service-offering/tests/option-group-management.test.d.ts

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

package/dist/document-models/service-offering/tests/option-group-management.test.d.ts.map

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

package/dist/document-models/service-offering/tests/option-group-management.test.js

@@ -0,0 +1,35 @@
+import { generateMock } from "@powerhousedao/codegen";
+import { describe, expect, it } from "vitest";
+import { reducer, utils, isServiceOfferingDocument, addOptionGroup, updateOptionGroup, deleteOptionGroup, AddOptionGroupInputSchema, UpdateOptionGroupInputSchema, DeleteOptionGroupInputSchema, } from "@powerhousedao/service-offering/document-models/service-offering";
+describe("OptionGroupManagementOperations", () => {
+    it("should handle addOptionGroup operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(AddOptionGroupInputSchema());
+        const updatedDocument = reducer(document, addOptionGroup(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("ADD_OPTION_GROUP");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle updateOptionGroup operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(UpdateOptionGroupInputSchema());
+        const updatedDocument = reducer(document, updateOptionGroup(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_OPTION_GROUP");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle deleteOptionGroup operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(DeleteOptionGroupInputSchema());
+        const updatedDocument = reducer(document, deleteOptionGroup(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("DELETE_OPTION_GROUP");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+});

package/dist/document-models/service-offering/tests/service-group-management.test.d.ts

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

package/dist/document-models/service-offering/tests/service-group-management.test.d.ts.map

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

package/dist/document-models/service-offering/tests/service-group-management.test.js

@@ -0,0 +1,45 @@
+import { generateMock } from "@powerhousedao/codegen";
+import { describe, expect, it } from "vitest";
+import { reducer, utils, isServiceOfferingDocument, addServiceGroup, updateServiceGroup, deleteServiceGroup, reorderServiceGroups, AddServiceGroupInputSchema, UpdateServiceGroupInputSchema, DeleteServiceGroupInputSchema, ReorderServiceGroupsInputSchema, } from "@powerhousedao/service-offering/document-models/service-offering";
+describe("ServiceGroupManagementOperations", () => {
+    it("should handle addServiceGroup operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(AddServiceGroupInputSchema());
+        const updatedDocument = reducer(document, addServiceGroup(input));
+        expect(isServiceOfferingDocument(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 updateServiceGroup operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(UpdateServiceGroupInputSchema());
+        const updatedDocument = reducer(document, updateServiceGroup(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_SERVICE_GROUP");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle deleteServiceGroup operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(DeleteServiceGroupInputSchema());
+        const updatedDocument = reducer(document, deleteServiceGroup(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("DELETE_SERVICE_GROUP");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle reorderServiceGroups operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(ReorderServiceGroupsInputSchema());
+        const updatedDocument = reducer(document, reorderServiceGroups(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("REORDER_SERVICE_GROUPS");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+});

package/dist/document-models/service-offering/tests/service-management.test.d.ts

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

package/dist/document-models/service-offering/tests/service-management.test.d.ts.map

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

package/dist/document-models/service-offering/tests/service-management.test.js

@@ -0,0 +1,55 @@
+import { generateMock } from "@powerhousedao/codegen";
+import { describe, expect, it } from "vitest";
+import { reducer, utils, isServiceOfferingDocument, addService, updateService, deleteService, addFacetBinding, removeFacetBinding, AddServiceInputSchema, UpdateServiceInputSchema, DeleteServiceInputSchema, AddFacetBindingInputSchema, RemoveFacetBindingInputSchema, } from "@powerhousedao/service-offering/document-models/service-offering";
+describe("ServiceManagementOperations", () => {
+    it("should handle addService operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(AddServiceInputSchema());
+        const updatedDocument = reducer(document, addService(input));
+        expect(isServiceOfferingDocument(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 updateService operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(UpdateServiceInputSchema());
+        const updatedDocument = reducer(document, updateService(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_SERVICE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle deleteService operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(DeleteServiceInputSchema());
+        const updatedDocument = reducer(document, deleteService(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("DELETE_SERVICE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle addFacetBinding operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(AddFacetBindingInputSchema());
+        const updatedDocument = reducer(document, addFacetBinding(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("ADD_FACET_BINDING");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle removeFacetBinding operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(RemoveFacetBindingInputSchema());
+        const updatedDocument = reducer(document, removeFacetBinding(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("REMOVE_FACET_BINDING");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+});

package/dist/document-models/service-offering/tests/tier-management.test.d.ts

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

package/dist/document-models/service-offering/tests/tier-management.test.d.ts.map

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

package/dist/document-models/service-offering/tests/tier-management.test.js

@@ -0,0 +1,135 @@
+import { generateMock } from "@powerhousedao/codegen";
+import { describe, expect, it } from "vitest";
+import { reducer, utils, isServiceOfferingDocument, addTier, updateTier, updateTierPricing, deleteTier, addTierPricingOption, updateTierPricingOption, removeTierPricingOption, addServiceLevel, updateServiceLevel, removeServiceLevel, addUsageLimit, updateUsageLimit, removeUsageLimit, AddTierInputSchema, UpdateTierInputSchema, UpdateTierPricingInputSchema, DeleteTierInputSchema, AddTierPricingOptionInputSchema, UpdateTierPricingOptionInputSchema, RemoveTierPricingOptionInputSchema, AddServiceLevelInputSchema, UpdateServiceLevelInputSchema, RemoveServiceLevelInputSchema, AddUsageLimitInputSchema, UpdateUsageLimitInputSchema, RemoveUsageLimitInputSchema, } from "@powerhousedao/service-offering/document-models/service-offering";
+describe("TierManagementOperations", () => {
+    it("should handle addTier operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(AddTierInputSchema());
+        const updatedDocument = reducer(document, addTier(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("ADD_TIER");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle updateTier operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(UpdateTierInputSchema());
+        const updatedDocument = reducer(document, updateTier(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_TIER");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle updateTierPricing operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(UpdateTierPricingInputSchema());
+        const updatedDocument = reducer(document, updateTierPricing(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_TIER_PRICING");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle deleteTier operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(DeleteTierInputSchema());
+        const updatedDocument = reducer(document, deleteTier(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("DELETE_TIER");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle addTierPricingOption operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(AddTierPricingOptionInputSchema());
+        const updatedDocument = reducer(document, addTierPricingOption(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("ADD_TIER_PRICING_OPTION");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle updateTierPricingOption operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(UpdateTierPricingOptionInputSchema());
+        const updatedDocument = reducer(document, updateTierPricingOption(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_TIER_PRICING_OPTION");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle removeTierPricingOption operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(RemoveTierPricingOptionInputSchema());
+        const updatedDocument = reducer(document, removeTierPricingOption(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("REMOVE_TIER_PRICING_OPTION");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle addServiceLevel operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(AddServiceLevelInputSchema());
+        const updatedDocument = reducer(document, addServiceLevel(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("ADD_SERVICE_LEVEL");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle updateServiceLevel operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(UpdateServiceLevelInputSchema());
+        const updatedDocument = reducer(document, updateServiceLevel(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_SERVICE_LEVEL");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle removeServiceLevel operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(RemoveServiceLevelInputSchema());
+        const updatedDocument = reducer(document, removeServiceLevel(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("REMOVE_SERVICE_LEVEL");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle addUsageLimit operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(AddUsageLimitInputSchema());
+        const updatedDocument = reducer(document, addUsageLimit(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("ADD_USAGE_LIMIT");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle updateUsageLimit operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(UpdateUsageLimitInputSchema());
+        const updatedDocument = reducer(document, updateUsageLimit(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_USAGE_LIMIT");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle removeUsageLimit operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(RemoveUsageLimitInputSchema());
+        const updatedDocument = reducer(document, removeUsageLimit(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("REMOVE_USAGE_LIMIT");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+});

package/dist/document-models/service-offering/utils.d.ts

@@ -0,0 +1,14 @@
+import type { ServiceOfferingPHState } from "./gen/types.js";
+/** Utils for the ServiceOffering document model */
+export declare const utils: {
+    fileExtension: string;
+    createState: import("document-model").CreateState<ServiceOfferingPHState>;
+    createDocument: import("document-model").CreateDocument<ServiceOfferingPHState>;
+    loadFromInput: import("document-model").LoadFromInput<ServiceOfferingPHState>;
+    saveToFileHandle: import("document-model").SaveToFileHandle;
+    isStateOfType: import("document-model").IsStateOfType<ServiceOfferingPHState>;
+    assertIsStateOfType: import("document-model").AssertIsStateOfType<ServiceOfferingPHState>;
+    isDocumentOfType: import("document-model").IsDocumentOfType<ServiceOfferingPHState>;
+    assertIsDocumentOfType: import("document-model").AssertIsDocumentOfType<ServiceOfferingPHState>;
+};
+//# sourceMappingURL=utils.d.ts.map

package/dist/document-models/service-offering/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../document-models/service-offering/utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAI7D,mDAAmD;AACnD,eAAO,MAAM,KAAK;;;;;;;;;;CAGoC,CAAC"}

package/dist/document-models/service-offering/utils.js

@@ -0,0 +1,7 @@
+import { utils as genUtils } from "./gen/utils.js";
+import * as customUtils from "./src/utils.js";
+/** Utils for the ServiceOffering document model */
+export const utils = {
+    ...genUtils,
+    ...customUtils,
+};

package/dist/document-models/service-subscription/actions.d.ts

@@ -0,0 +1,24 @@
+/** Actions for the ServiceSubscription document model */
+export declare const actions: {
+    updateBillingProjection: (input: import("./index.js").UpdateBillingProjectionInput) => import("./index.js").UpdateBillingProjectionAction;
+    setCachedSnippets: (input: import("./index.js").SetCachedSnippetsInput) => import("./index.js").SetCachedSnippetsAction;
+    setFacetSelection: (input: import("./index.js").SetFacetSelectionInput) => import("./index.js").SetFacetSelectionAction;
+    removeFacetSelection: (input: import("./index.js").RemoveFacetSelectionInput) => import("./index.js").RemoveFacetSelectionAction;
+    addAddon: (input: import("./index.js").AddAddonInput) => import("./index.js").AddAddonAction;
+    removeAddon: (input: import("./index.js").RemoveAddonInput) => import("./index.js").RemoveAddonAction;
+    changeTier: (input: import("./index.js").ChangeTierInput) => import("./index.js").ChangeTierAction;
+    setPricing: (input: import("./index.js").SetPricingInput) => import("./index.js").SetPricingAction;
+    initializeSubscription: (input: import("./index.js").InitializeSubscriptionInput) => import("./index.js").InitializeSubscriptionAction;
+    activateSubscription: (input: import("./index.js").ActivateSubscriptionInput) => import("./index.js").ActivateSubscriptionAction;
+    cancelSubscription: (input: import("./index.js").CancelSubscriptionInput) => import("./index.js").CancelSubscriptionAction;
+    expireSubscription: (input: import("./index.js").ExpireSubscriptionInput) => import("./index.js").ExpireSubscriptionAction;
+    setName: (name: string) => import("document-model").SetNameAction;
+    undo: (skip?: number, scope?: string) => import("document-model").UndoAction;
+    redo: (count?: number, scope?: string) => import("document-model").RedoAction;
+    prune: (start?: number, end?: number, scope?: string) => import("document-model").SchemaPruneAction;
+    loadState: <TState extends import("document-model").PHBaseState = import("document-model").PHBaseState>(state: TState & {
+        name: string;
+    }, operations: number) => import("document-model").LoadStateAction;
+    noop: (scope?: string) => import("document-model").NOOPAction;
+};
+//# sourceMappingURL=actions.d.ts.map

package/dist/document-models/service-subscription/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../document-models/service-subscription/actions.ts"],"names":[],"mappings":"AASA,yDAAyD;AAEzD,eAAO,MAAM,OAAO;8BAIf,wDACM;wBAGsJ,kDAA6B;wBAL7K,kDACE;2BAI0G,qDAAgC;eAR3I,yCACL;kBAOZ,4CAAuB;iBARD,2CAErB;iBAMW,2CAAsB;6BAA4D,uDAAkC;2BAAmN,qDAAgC;yBAA2M,mDAA8B;yBAAqM,mDAA8B;;eAAm2L,CAAC,eAAe,CAAC;gBAAkE,CAAC,eAAe,CAAC;iBAAmE,CAAC,aAAa,CAAC,eAAe,CAAC;;;;gBAAqS,CAAC;CAD9oO,CAAC"}

package/dist/document-models/service-subscription/actions.js

@@ -0,0 +1,11 @@
+import { baseActions } from "document-model";
+import { subscriptionManagementActions, tierSelectionActions, addOnManagementActions, facetSelectionActions, billingProjectionActions, } from "./gen/creators.js";
+/** Actions for the ServiceSubscription document model */
+export const actions = {
+    ...baseActions,
+    ...subscriptionManagementActions,
+    ...tierSelectionActions,
+    ...addOnManagementActions,
+    ...facetSelectionActions,
+    ...billingProjectionActions,
+};