@powerhousedao/network-admin 0.0.64 → 1.0.0-dev.2

package/dist/document-models/payment-terms/gen/document-schema.d.ts

@@ -1,95 +0,0 @@
-import { z } from "zod";
-import type { PaymentTermsDocument, PaymentTermsPHState } from "./types.js";
-/** Schema for validating the header object of a PaymentTerms document */
-export declare const PaymentTermsDocumentHeaderSchema: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    createdAtUtcIso: z.ZodString;
-    lastModifiedAtUtcIso: z.ZodString;
-    documentType: z.ZodLiteral<"payment-terms">;
-}, z.core.$strip>;
-/** Schema for validating the state object of a PaymentTerms document */
-export declare const PaymentTermsPHStateSchema: z.ZodObject<{
-    global: z.ZodObject<Required<{
-        bonusClauses: z.ZodType<import("./types.js").BonusClause[], unknown, z.core.$ZodTypeInternals<import("./types.js").BonusClause[], unknown>>;
-        currency: z.ZodType<import("./types.js").PaymentCurrency, unknown, z.core.$ZodTypeInternals<import("./types.js").PaymentCurrency, unknown>>;
-        escrowDetails: z.ZodType<import("./types.js").Maybe<import("./types.js").Escrow>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").Escrow>, unknown>>;
-        evaluation: z.ZodType<import("./types.js").Maybe<import("./types.js").EvaluationTerms>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").EvaluationTerms>, unknown>>;
-        milestoneSchedule: z.ZodType<import("./types.js").Milestone[], unknown, z.core.$ZodTypeInternals<import("./types.js").Milestone[], unknown>>;
-        payer: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
-        paymentModel: z.ZodType<import("./types.js").PaymentModel, unknown, z.core.$ZodTypeInternals<import("./types.js").PaymentModel, unknown>>;
-        penaltyClauses: z.ZodType<import("./types.js").PenaltyClause[], unknown, z.core.$ZodTypeInternals<import("./types.js").PenaltyClause[], unknown>>;
-        proposer: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
-        status: z.ZodType<import("./types.js").PaymentTermsStatus, unknown, z.core.$ZodTypeInternals<import("./types.js").PaymentTermsStatus, unknown>>;
-        timeAndMaterials: z.ZodType<import("./types.js").Maybe<import("./types.js").TimeAndMaterials>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").TimeAndMaterials>, unknown>>;
-        totalAmount: z.ZodType<import("./types.js").Maybe<{
-            unit?: string;
-            value?: number;
-        }>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<{
-            unit?: string;
-            value?: number;
-        }>, unknown>>;
-    }>, z.core.$strip>;
-}, z.core.$strip>;
-export declare const PaymentTermsDocumentSchema: z.ZodObject<{
-    header: z.ZodObject<{
-        id: z.ZodString;
-        name: z.ZodString;
-        createdAtUtcIso: z.ZodString;
-        lastModifiedAtUtcIso: z.ZodString;
-        documentType: z.ZodLiteral<"payment-terms">;
-    }, z.core.$strip>;
-    state: z.ZodObject<{
-        global: z.ZodObject<Required<{
-            bonusClauses: z.ZodType<import("./types.js").BonusClause[], unknown, z.core.$ZodTypeInternals<import("./types.js").BonusClause[], unknown>>;
-            currency: z.ZodType<import("./types.js").PaymentCurrency, unknown, z.core.$ZodTypeInternals<import("./types.js").PaymentCurrency, unknown>>;
-            escrowDetails: z.ZodType<import("./types.js").Maybe<import("./types.js").Escrow>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").Escrow>, unknown>>;
-            evaluation: z.ZodType<import("./types.js").Maybe<import("./types.js").EvaluationTerms>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").EvaluationTerms>, unknown>>;
-            milestoneSchedule: z.ZodType<import("./types.js").Milestone[], unknown, z.core.$ZodTypeInternals<import("./types.js").Milestone[], unknown>>;
-            payer: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
-            paymentModel: z.ZodType<import("./types.js").PaymentModel, unknown, z.core.$ZodTypeInternals<import("./types.js").PaymentModel, unknown>>;
-            penaltyClauses: z.ZodType<import("./types.js").PenaltyClause[], unknown, z.core.$ZodTypeInternals<import("./types.js").PenaltyClause[], unknown>>;
-            proposer: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
-            status: z.ZodType<import("./types.js").PaymentTermsStatus, unknown, z.core.$ZodTypeInternals<import("./types.js").PaymentTermsStatus, unknown>>;
-            timeAndMaterials: z.ZodType<import("./types.js").Maybe<import("./types.js").TimeAndMaterials>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").TimeAndMaterials>, unknown>>;
-            totalAmount: z.ZodType<import("./types.js").Maybe<{
-                unit?: string;
-                value?: number;
-            }>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<{
-                unit?: string;
-                value?: number;
-            }>, unknown>>;
-        }>, z.core.$strip>;
-    }, z.core.$strip>;
-    initialState: z.ZodObject<{
-        global: z.ZodObject<Required<{
-            bonusClauses: z.ZodType<import("./types.js").BonusClause[], unknown, z.core.$ZodTypeInternals<import("./types.js").BonusClause[], unknown>>;
-            currency: z.ZodType<import("./types.js").PaymentCurrency, unknown, z.core.$ZodTypeInternals<import("./types.js").PaymentCurrency, unknown>>;
-            escrowDetails: z.ZodType<import("./types.js").Maybe<import("./types.js").Escrow>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").Escrow>, unknown>>;
-            evaluation: z.ZodType<import("./types.js").Maybe<import("./types.js").EvaluationTerms>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").EvaluationTerms>, unknown>>;
-            milestoneSchedule: z.ZodType<import("./types.js").Milestone[], unknown, z.core.$ZodTypeInternals<import("./types.js").Milestone[], unknown>>;
-            payer: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
-            paymentModel: z.ZodType<import("./types.js").PaymentModel, unknown, z.core.$ZodTypeInternals<import("./types.js").PaymentModel, unknown>>;
-            penaltyClauses: z.ZodType<import("./types.js").PenaltyClause[], unknown, z.core.$ZodTypeInternals<import("./types.js").PenaltyClause[], unknown>>;
-            proposer: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
-            status: z.ZodType<import("./types.js").PaymentTermsStatus, unknown, z.core.$ZodTypeInternals<import("./types.js").PaymentTermsStatus, unknown>>;
-            timeAndMaterials: z.ZodType<import("./types.js").Maybe<import("./types.js").TimeAndMaterials>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").TimeAndMaterials>, unknown>>;
-            totalAmount: z.ZodType<import("./types.js").Maybe<{
-                unit?: string;
-                value?: number;
-            }>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<{
-                unit?: string;
-                value?: number;
-            }>, unknown>>;
-        }>, z.core.$strip>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-/** Simple helper function to check if a state object is a PaymentTerms document state object */
-export declare function isPaymentTermsState(state: unknown): state is PaymentTermsPHState;
-/** Simple helper function to assert that a document state object is a PaymentTerms document state object */
-export declare function assertIsPaymentTermsState(state: unknown): asserts state is PaymentTermsPHState;
-/** Simple helper function to check if a document is a PaymentTerms document */
-export declare function isPaymentTermsDocument(document: unknown): document is PaymentTermsDocument;
-/** Simple helper function to assert that a document is a PaymentTerms document */
-export declare function assertIsPaymentTermsDocument(document: unknown): asserts document is PaymentTermsDocument;
-//# sourceMappingURL=document-schema.d.ts.map

package/dist/document-models/payment-terms/gen/document-schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"document-schema.d.ts","sourceRoot":"","sources":["../../../../document-models/payment-terms/gen/document-schema.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAE5E,yEAAyE;AACzE,eAAO,MAAM,gCAAgC;;;;;;iBAI5C,CAAC;AAEF,wEAAwE;AACxE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;iBAEpC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIrC,CAAC;AAEH,gGAAgG;AAChG,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,mBAAmB,CAE9B;AAED,4GAA4G;AAC5G,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,KAAK,IAAI,mBAAmB,CAEtC;AAED,+EAA+E;AAC/E,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,OAAO,GAChB,QAAQ,IAAI,oBAAoB,CAElC;AAED,kFAAkF;AAClF,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,OAAO,GAChB,OAAO,CAAC,QAAQ,IAAI,oBAAoB,CAE1C"}

package/dist/document-models/request-for-proposals/gen/document-schema.d.ts

@@ -1,83 +0,0 @@
-import { z } from "zod";
-import type { RequestForProposalsDocument, RequestForProposalsPHState } from "./types.js";
-/** Schema for validating the header object of a RequestForProposals document */
-export declare const RequestForProposalsDocumentHeaderSchema: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    createdAtUtcIso: z.ZodString;
-    lastModifiedAtUtcIso: z.ZodString;
-    documentType: z.ZodLiteral<"powerhouse/rfp">;
-}, z.core.$strip>;
-/** Schema for validating the state object of a RequestForProposals document */
-export declare const RequestForProposalsPHStateSchema: z.ZodObject<{
-    global: z.ZodObject<Required<{
-        briefing: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
-        budgetRange: z.ZodType<import("./types.js").BudgetRange, unknown, z.core.$ZodTypeInternals<import("./types.js").BudgetRange, unknown>>;
-        code: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
-        contextDocuments: z.ZodType<import("./types.js").ContextDocument[], unknown, z.core.$ZodTypeInternals<import("./types.js").ContextDocument[], unknown>>;
-        deadline: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
-        eligibilityCriteria: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
-        evaluationCriteria: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
-        issuer: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
-        proposals: z.ZodType<import("./types.js").RfpProposal[], unknown, z.core.$ZodTypeInternals<import("./types.js").RfpProposal[], unknown>>;
-        rfpCommenter: z.ZodType<import("./types.js").RfpCommenter[], unknown, z.core.$ZodTypeInternals<import("./types.js").RfpCommenter[], unknown>>;
-        status: z.ZodType<import("./types.js").RfpStatus, unknown, z.core.$ZodTypeInternals<import("./types.js").RfpStatus, unknown>>;
-        summary: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
-        tags: z.ZodType<import("./types.js").Maybe<string[]>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string[]>, unknown>>;
-        title: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
-    }>, z.core.$strip>;
-}, z.core.$strip>;
-export declare const RequestForProposalsDocumentSchema: z.ZodObject<{
-    header: z.ZodObject<{
-        id: z.ZodString;
-        name: z.ZodString;
-        createdAtUtcIso: z.ZodString;
-        lastModifiedAtUtcIso: z.ZodString;
-        documentType: z.ZodLiteral<"powerhouse/rfp">;
-    }, z.core.$strip>;
-    state: z.ZodObject<{
-        global: z.ZodObject<Required<{
-            briefing: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
-            budgetRange: z.ZodType<import("./types.js").BudgetRange, unknown, z.core.$ZodTypeInternals<import("./types.js").BudgetRange, unknown>>;
-            code: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
-            contextDocuments: z.ZodType<import("./types.js").ContextDocument[], unknown, z.core.$ZodTypeInternals<import("./types.js").ContextDocument[], unknown>>;
-            deadline: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
-            eligibilityCriteria: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
-            evaluationCriteria: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
-            issuer: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
-            proposals: z.ZodType<import("./types.js").RfpProposal[], unknown, z.core.$ZodTypeInternals<import("./types.js").RfpProposal[], unknown>>;
-            rfpCommenter: z.ZodType<import("./types.js").RfpCommenter[], unknown, z.core.$ZodTypeInternals<import("./types.js").RfpCommenter[], unknown>>;
-            status: z.ZodType<import("./types.js").RfpStatus, unknown, z.core.$ZodTypeInternals<import("./types.js").RfpStatus, unknown>>;
-            summary: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
-            tags: z.ZodType<import("./types.js").Maybe<string[]>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string[]>, unknown>>;
-            title: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
-        }>, z.core.$strip>;
-    }, z.core.$strip>;
-    initialState: z.ZodObject<{
-        global: z.ZodObject<Required<{
-            briefing: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
-            budgetRange: z.ZodType<import("./types.js").BudgetRange, unknown, z.core.$ZodTypeInternals<import("./types.js").BudgetRange, unknown>>;
-            code: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
-            contextDocuments: z.ZodType<import("./types.js").ContextDocument[], unknown, z.core.$ZodTypeInternals<import("./types.js").ContextDocument[], unknown>>;
-            deadline: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
-            eligibilityCriteria: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
-            evaluationCriteria: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
-            issuer: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
-            proposals: z.ZodType<import("./types.js").RfpProposal[], unknown, z.core.$ZodTypeInternals<import("./types.js").RfpProposal[], unknown>>;
-            rfpCommenter: z.ZodType<import("./types.js").RfpCommenter[], unknown, z.core.$ZodTypeInternals<import("./types.js").RfpCommenter[], unknown>>;
-            status: z.ZodType<import("./types.js").RfpStatus, unknown, z.core.$ZodTypeInternals<import("./types.js").RfpStatus, unknown>>;
-            summary: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
-            tags: z.ZodType<import("./types.js").Maybe<string[]>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string[]>, unknown>>;
-            title: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
-        }>, z.core.$strip>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-/** Simple helper function to check if a state object is a RequestForProposals document state object */
-export declare function isRequestForProposalsState(state: unknown): state is RequestForProposalsPHState;
-/** Simple helper function to assert that a document state object is a RequestForProposals document state object */
-export declare function assertIsRequestForProposalsState(state: unknown): asserts state is RequestForProposalsPHState;
-/** Simple helper function to check if a document is a RequestForProposals document */
-export declare function isRequestForProposalsDocument(document: unknown): document is RequestForProposalsDocument;
-/** Simple helper function to assert that a document is a RequestForProposals document */
-export declare function assertIsRequestForProposalsDocument(document: unknown): asserts document is RequestForProposalsDocument;
-//# sourceMappingURL=document-schema.d.ts.map

package/dist/document-models/request-for-proposals/gen/document-schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"document-schema.d.ts","sourceRoot":"","sources":["../../../../document-models/request-for-proposals/gen/document-schema.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EACV,2BAA2B,EAC3B,0BAA0B,EAC3B,MAAM,YAAY,CAAC;AAEpB,gFAAgF;AAChF,eAAO,MAAM,uCAAuC;;;;;;iBAGhD,CAAC;AAEL,+EAA+E;AAC/E,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;iBAE3C,CAAC;AAEH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAI5C,CAAC;AAEH,uGAAuG;AACvG,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,0BAA0B,CAErC;AAED,mHAAmH;AACnH,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,KAAK,IAAI,0BAA0B,CAE7C;AAED,sFAAsF;AACtF,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,OAAO,GAChB,QAAQ,IAAI,2BAA2B,CAEzC;AAED,yFAAyF;AACzF,wBAAgB,mCAAmC,CACjD,QAAQ,EAAE,OAAO,GAChB,OAAO,CAAC,QAAQ,IAAI,2BAA2B,CAEjD"}

package/dist/document-models/workstream/gen/document-schema.d.ts

@@ -1,71 +0,0 @@
-import { z } from "zod";
-import type { WorkstreamDocument, WorkstreamPHState } from "./types.js";
-/** Schema for validating the header object of a Workstream document */
-export declare const WorkstreamDocumentHeaderSchema: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    createdAtUtcIso: z.ZodString;
-    lastModifiedAtUtcIso: z.ZodString;
-    documentType: z.ZodLiteral<"powerhouse/workstream">;
-}, z.core.$strip>;
-/** Schema for validating the state object of a Workstream document */
-export declare const WorkstreamPHStateSchema: z.ZodObject<{
-    global: z.ZodObject<Required<{
-        alternativeProposals: z.ZodType<import("./types.js").Proposal[], unknown, z.core.$ZodTypeInternals<import("./types.js").Proposal[], unknown>>;
-        client: z.ZodType<import("./types.js").Maybe<import("./types.js").ClientInfo>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").ClientInfo>, unknown>>;
-        code: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
-        initialProposal: z.ZodType<import("./types.js").Maybe<import("./types.js").Proposal>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").Proposal>, unknown>>;
-        paymentRequests: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
-        paymentTerms: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
-        rfp: z.ZodType<import("./types.js").Maybe<import("./types.js").Rfp>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").Rfp>, unknown>>;
-        sow: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
-        status: z.ZodType<import("./types.js").WorkstreamStatus, unknown, z.core.$ZodTypeInternals<import("./types.js").WorkstreamStatus, unknown>>;
-        title: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
-    }>, z.core.$strip>;
-}, z.core.$strip>;
-export declare const WorkstreamDocumentSchema: z.ZodObject<{
-    header: z.ZodObject<{
-        id: z.ZodString;
-        name: z.ZodString;
-        createdAtUtcIso: z.ZodString;
-        lastModifiedAtUtcIso: z.ZodString;
-        documentType: z.ZodLiteral<"powerhouse/workstream">;
-    }, z.core.$strip>;
-    state: z.ZodObject<{
-        global: z.ZodObject<Required<{
-            alternativeProposals: z.ZodType<import("./types.js").Proposal[], unknown, z.core.$ZodTypeInternals<import("./types.js").Proposal[], unknown>>;
-            client: z.ZodType<import("./types.js").Maybe<import("./types.js").ClientInfo>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").ClientInfo>, unknown>>;
-            code: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
-            initialProposal: z.ZodType<import("./types.js").Maybe<import("./types.js").Proposal>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").Proposal>, unknown>>;
-            paymentRequests: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
-            paymentTerms: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
-            rfp: z.ZodType<import("./types.js").Maybe<import("./types.js").Rfp>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").Rfp>, unknown>>;
-            sow: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
-            status: z.ZodType<import("./types.js").WorkstreamStatus, unknown, z.core.$ZodTypeInternals<import("./types.js").WorkstreamStatus, unknown>>;
-            title: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
-        }>, z.core.$strip>;
-    }, z.core.$strip>;
-    initialState: z.ZodObject<{
-        global: z.ZodObject<Required<{
-            alternativeProposals: z.ZodType<import("./types.js").Proposal[], unknown, z.core.$ZodTypeInternals<import("./types.js").Proposal[], unknown>>;
-            client: z.ZodType<import("./types.js").Maybe<import("./types.js").ClientInfo>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").ClientInfo>, unknown>>;
-            code: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
-            initialProposal: z.ZodType<import("./types.js").Maybe<import("./types.js").Proposal>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").Proposal>, unknown>>;
-            paymentRequests: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
-            paymentTerms: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
-            rfp: z.ZodType<import("./types.js").Maybe<import("./types.js").Rfp>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").Rfp>, unknown>>;
-            sow: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
-            status: z.ZodType<import("./types.js").WorkstreamStatus, unknown, z.core.$ZodTypeInternals<import("./types.js").WorkstreamStatus, unknown>>;
-            title: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
-        }>, z.core.$strip>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-/** Simple helper function to check if a state object is a Workstream document state object */
-export declare function isWorkstreamState(state: unknown): state is WorkstreamPHState;
-/** Simple helper function to assert that a document state object is a Workstream document state object */
-export declare function assertIsWorkstreamState(state: unknown): asserts state is WorkstreamPHState;
-/** Simple helper function to check if a document is a Workstream document */
-export declare function isWorkstreamDocument(document: unknown): document is WorkstreamDocument;
-/** Simple helper function to assert that a document is a Workstream document */
-export declare function assertIsWorkstreamDocument(document: unknown): asserts document is WorkstreamDocument;
-//# sourceMappingURL=document-schema.d.ts.map

package/dist/document-models/workstream/gen/document-schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"document-schema.d.ts","sourceRoot":"","sources":["../../../../document-models/workstream/gen/document-schema.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAExE,uEAAuE;AACvE,eAAO,MAAM,8BAA8B;;;;;;iBAEzC,CAAC;AAEH,sEAAsE;AACtE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;iBAElC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAInC,CAAC;AAEH,8FAA8F;AAC9F,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,iBAAiB,CAE5E;AAED,0GAA0G;AAC1G,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,KAAK,IAAI,iBAAiB,CAEpC;AAED,6EAA6E;AAC7E,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,OAAO,GAChB,QAAQ,IAAI,kBAAkB,CAEhC;AAED,gFAAgF;AAChF,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,OAAO,GAChB,OAAO,CAAC,QAAQ,IAAI,kBAAkB,CAExC"}

package/dist/editors/builders/editor.d.ts

@@ -1,3 +0,0 @@
-/** Implement your editor behavior here */
-export default function Editor(): import("react/jsx-runtime").JSX.Element;
-//# sourceMappingURL=editor.d.ts.map

package/dist/editors/builders/editor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"editor.d.ts","sourceRoot":"","sources":["../../../editors/builders/editor.tsx"],"names":[],"mappings":"AAgJA,0CAA0C;AAC1C,MAAM,CAAC,OAAO,UAAU,MAAM,4CAkT7B"}

package/dist/editors/builders/editor.js

@@ -1,285 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { DocumentToolbar } from "@powerhousedao/design-system/connect";
-import { useSelectedBuildersDocument } from "../../document-models/builders/hooks.js";
-import { actions as buildersActions } from "../../document-models/builders/actions.js";
-import { setSelectedNode, useParentFolderForSelectedNode, useDrives, useDocuments, } from "@powerhousedao/reactor-browser";
-import { useMemo, useCallback, useState, useEffect } from "react";
-import { ObjectSetTable, PHIDInput, } from "@powerhousedao/document-engineering";
-import { useRemoteBuilderProfiles } from "./hooks/useRemoteBuilderProfiles.js";
-/**
- * Wrapper component for PHIDInput that properly tracks selected PHID
- * and handles saving on blur/enter with the correct PHID value.
- */
-function BuilderPHIDInput({ initialPhid, options, onSave, fetchOptionsCallback, }) {
-    const [inputText, setInputText] = useState("");
-    const [hasSaved, setHasSaved] = useState(false);
-    useEffect(() => {
-        setInputText("");
-        setHasSaved(false);
-    }, [initialPhid]);
-    const findPhidByInput = useCallback((input) => {
-        const trimmed = input.trim();
-        if (!trimmed)
-            return null;
-        const lowerInput = trimmed.toLowerCase();
-        const exactMatchByName = options.find((opt) => opt.label.toLowerCase() === lowerInput);
-        if (exactMatchByName)
-            return exactMatchByName.id;
-        const partialMatchByName = options.find((opt) => opt.label.toLowerCase().startsWith(lowerInput));
-        if (partialMatchByName)
-            return partialMatchByName.id;
-        const containsMatches = options.filter((opt) => opt.label.toLowerCase().includes(lowerInput));
-        if (containsMatches.length === 1)
-            return containsMatches[0].id;
-        const matchById = options.find((opt) => opt.id.toLowerCase() === lowerInput);
-        if (matchById)
-            return matchById.id;
-        const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-        if (uuidRegex.test(trimmed))
-            return trimmed;
-        return null;
-    }, [options]);
-    const isKnownPhid = useCallback((value) => {
-        return options.some((opt) => opt.id === value);
-    }, [options]);
-    const savePhid = useCallback((phid) => {
-        if (!hasSaved && phid && phid !== initialPhid) {
-            setHasSaved(true);
-            onSave(phid);
-        }
-    }, [hasSaved, initialPhid, onSave]);
-    const handleBlur = useCallback(() => {
-        if (hasSaved)
-            return;
-        if (inputText) {
-            const foundPhid = findPhidByInput(inputText);
-            if (foundPhid) {
-                savePhid(foundPhid);
-            }
-        }
-    }, [hasSaved, inputText, findPhidByInput, savePhid]);
-    return (_jsx(PHIDInput, { value: initialPhid, onChange: (newValue) => {
-            if (isKnownPhid(newValue)) {
-                savePhid(newValue);
-            }
-        }, onInput: (e) => {
-            const target = e.target;
-            setInputText(target.value);
-        }, onBlur: handleBlur, placeholder: "Enter PHID or search by name", className: "w-full", variant: "withValueAndTitle", initialOptions: options, fetchOptionsCallback: fetchOptionsCallback }));
-}
-/** Implement your editor behavior here */
-export default function Editor() {
-    const [doc, dispatch] = useSelectedBuildersDocument();
-    // Get the parent folder node for the currently selected node
-    const parentFolder = useParentFolderForSelectedNode();
-    // Set the selected node to the parent folder node (close the editor)
-    function handleClose() {
-        setSelectedNode(parentFolder?.id);
-    }
-    const drives = useDrives();
-    // Map all builder profile FileNodes from all drives with their driveId
-    const builderProfileNodesWithDriveId = useMemo(() => {
-        if (!drives)
-            return [];
-        return drives.flatMap((drive) => {
-            const builderProfileNodes = drive.state.global.nodes.filter((node) => node.kind === "file" &&
-                "documentType" in node &&
-                node.documentType === "powerhouse/builder-profile");
-            return builderProfileNodes.map((node) => ({
-                node,
-                driveId: drive.header.id,
-            }));
-        });
-    }, [drives]);
-    // Get all unique builder PHIDs from the nodes
-    const builderPhids = useMemo(() => {
-        return builderProfileNodesWithDriveId.map(({ node }) => node.id);
-    }, [builderProfileNodesWithDriveId]);
-    // Fetch all builder profile documents from all drives
-    const builderProfileDocuments = useDocuments(builderPhids);
-    // Create a map of PHID to document for quick lookup (local drives)
-    const localBuilderProfileMap = useMemo(() => {
-        const map = new Map();
-        if (!builderProfileDocuments)
-            return map;
-        builderProfileDocuments.forEach((doc) => {
-            if (doc.header.documentType === "powerhouse/builder-profile") {
-                map.set(doc.header.id, doc);
-            }
-        });
-        return map;
-    }, [builderProfileDocuments]);
-    // Fetch remote profiles as fallback for builders not found locally
-    const { profileMap: remoteProfileMap, allProfiles: remoteProfiles } = useRemoteBuilderProfiles(localBuilderProfileMap);
-    // Helper function to get builder profile documents from all drives (local + remote)
-    const getBuilderProfiles = useCallback(() => {
-        // Start with local profiles
-        const profileOptions = builderProfileNodesWithDriveId.map(({ node }) => {
-            const doc = localBuilderProfileMap.get(node.id);
-            const name = doc?.state?.global?.name || node.name || node.id;
-            return {
-                id: node.id,
-                label: name,
-                value: node.id,
-                title: name,
-            };
-        });
-        // Add remote profiles that aren't already in local
-        const localIds = new Set(profileOptions.map((p) => p.id));
-        for (const remoteProfile of remoteProfiles) {
-            if (!localIds.has(remoteProfile.id)) {
-                const name = remoteProfile.state?.name || remoteProfile.id;
-                profileOptions.push({
-                    id: remoteProfile.id,
-                    label: name,
-                    value: remoteProfile.id,
-                    title: name,
-                });
-            }
-        }
-        return profileOptions;
-    }, [builderProfileNodesWithDriveId, localBuilderProfileMap, remoteProfiles]);
-    // Helper function to get builder profile data by PHID (local first, then remote fallback)
-    const getBuilderProfileByPhid = useCallback((phid) => {
-        // Try local first
-        const localDoc = localBuilderProfileMap.get(phid);
-        if (localDoc) {
-            return {
-                name: localDoc.state.global?.name || localDoc.header.id,
-                slug: localDoc.state.global?.slug || localDoc.header.id,
-                icon: localDoc.state.global?.icon || null,
-            };
-        }
-        // Fall back to remote
-        const remoteProfile = remoteProfileMap.get(phid);
-        if (remoteProfile) {
-            return {
-                name: remoteProfile.state?.name || remoteProfile.id,
-                slug: remoteProfile.state?.slug || remoteProfile.id,
-                icon: remoteProfile.state?.icon || null,
-            };
-        }
-        return null;
-    }, [localBuilderProfileMap, remoteProfileMap]);
-    const builders = useMemo(() => {
-        return (doc?.state.global.builders.map((phid) => {
-            const profile = getBuilderProfileByPhid(phid);
-            return {
-                phid: phid,
-                name: profile?.name || "",
-                slug: profile?.slug || "",
-                icon: profile?.icon || null,
-            };
-        }) || []);
-    }, [doc, getBuilderProfileByPhid]);
-    const columns = useMemo(() => [
-        {
-            field: "phid",
-            title: "PHID",
-            editable: true,
-            align: "center",
-            width: 200,
-            onSave: (newValue, context) => {
-                const currentId = context.row.phid || "";
-                if (newValue !== currentId && newValue && currentId) {
-                    // First remove the old builder
-                    dispatch(buildersActions.removeBuilder({ builderPhid: currentId }));
-                    // Then add the new builder with the new PHID
-                    dispatch(buildersActions.addBuilder({
-                        builderPhid: newValue,
-                    }));
-                    return true;
-                }
-                return false;
-            },
-            renderCellEditor: (_value, _onChange, context) => {
-                const currentPhid = context.row.phid || "";
-                const handleSave = (phidValue) => {
-                    // If a PHID is entered and it's different from current value
-                    if (phidValue && phidValue !== currentPhid) {
-                        const existingBuilder = builders.find((builder) => builder.phid === phidValue);
-                        if (!existingBuilder) {
-                            // If we're editing an existing row (has an ID), remove the old one first
-                            if (currentPhid && currentPhid !== phidValue) {
-                                dispatch(buildersActions.removeBuilder({
-                                    builderPhid: currentPhid,
-                                }));
-                            }
-                            // Add the new builder
-                            dispatch(buildersActions.addBuilder({
-                                builderPhid: phidValue,
-                            }));
-                        }
-                    }
-                };
-                const fetchOptions = (userInput) => {
-                    const builderProfiles = getBuilderProfiles();
-                    // Filter profiles based on user input
-                    if (!userInput.trim()) {
-                        return Promise.resolve(builderProfiles);
-                    }
-                    const filteredProfiles = builderProfiles.filter((profile) => profile.label.toLowerCase().includes(userInput.toLowerCase()) ||
-                        profile.id.toLowerCase().includes(userInput.toLowerCase()));
-                    return Promise.resolve(filteredProfiles);
-                };
-                return (_jsx(BuilderPHIDInput, { initialPhid: currentPhid, options: getBuilderProfiles(), onSave: handleSave, fetchOptionsCallback: fetchOptions }, `phid-input-${currentPhid || Date.now()}`));
-            },
-            renderCell: (value) => {
-                if (value === "" || !value) {
-                    return (_jsx("div", { className: "font-light italic text-gray-500 text-center", children: "+ Double-click to add new builder (enter or click outside to save)" }));
-                }
-                return _jsx("div", { className: "text-center font-mono text-sm", children: value });
-            },
-        },
-        {
-            field: "name",
-            title: "Builder Name",
-            editable: false,
-            align: "center",
-            width: 200,
-            renderCell: (value) => {
-                return _jsx("div", { className: "text-center", children: value });
-            },
-        },
-        {
-            field: "slug",
-            title: "Builder Slug",
-            editable: false,
-            align: "center",
-            width: 200,
-            renderCell: (value) => {
-                return _jsx("div", { className: "text-center", children: value });
-            },
-        },
-        {
-            field: "icon",
-            title: "Icon",
-            editable: false,
-            align: "center",
-            width: 150,
-            renderCell: (_value, context) => {
-                if (!context.row.icon) {
-                    return null;
-                }
-                return (_jsx("div", { className: "text-center", children: _jsx("img", { src: context.row.icon, alt: "Builder icon", className: "w-10 h-10 rounded-sm mx-auto object-cover", onError: (e) => {
-                            e.currentTarget.style.display = "none";
-                        } }) }));
-            },
-        },
-    ], [builders, getBuilderProfiles, dispatch]);
-    return (_jsxs("div", { className: "w-full bg-gray-50", children: [_jsx(DocumentToolbar, { document: doc, onClose: handleClose }), _jsxs("div", { className: "p-2 max-w-4xl mx-auto min-h-screen", children: [_jsx("div", { className: "bg-white rounded-lg p-6 mb-6 shadow-sm text-center", children: _jsx("h1", { className: "text-3xl font-bold text-gray-900 mb-2", children: "Builders" }) }), _jsx("div", { className: "mt-4 bg-white", children: _jsx(ObjectSetTable, { columns: columns, data: builders, allowRowSelection: true, onDelete: (data) => {
-                                if (data.length > 0) {
-                                    data.forEach((d) => {
-                                        dispatch(buildersActions.removeBuilder({ builderPhid: d.phid }));
-                                    });
-                                }
-                            }, onAdd: (data) => {
-                                // Only add if we have a PHID
-                                const phid = data.id;
-                                if (phid) {
-                                    dispatch(buildersActions.addBuilder({
-                                        builderPhid: phid,
-                                    }));
-                                }
-                            } }) })] })] }));
-}

package/dist/editors/builders/hooks/useRemoteBuilderProfiles.d.ts

@@ -1,20 +0,0 @@
-import { type RemoteBuilderProfile } from "../utils/graphql-client.js";
-interface UseRemoteBuilderProfilesResult {
-    /** Map of PHID to remote builder profile data */
-    profileMap: Map<string, RemoteBuilderProfile>;
-    /** All available remote profiles for selection */
-    allProfiles: RemoteBuilderProfile[];
-    /** Whether remote data is currently loading */
-    isLoading: boolean;
-    /** Manually refetch all available profiles */
-    refetchAll: () => Promise<void>;
-}
-/**
- * Hook for fetching builder profiles from remote Switchboard drives.
- * Used as a fallback when local drives don't have the builder profile documents.
- *
- * @param localProfileMap - Map of PHIDs that are already resolved locally (to avoid using remote data for those)
- */
-export declare function useRemoteBuilderProfiles(localProfileMap: Map<string, unknown>): UseRemoteBuilderProfilesResult;
-export {};
-//# sourceMappingURL=useRemoteBuilderProfiles.d.ts.map

package/dist/editors/builders/hooks/useRemoteBuilderProfiles.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useRemoteBuilderProfiles.d.ts","sourceRoot":"","sources":["../../../../editors/builders/hooks/useRemoteBuilderProfiles.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,oBAAoB,EAC1B,MAAM,4BAA4B,CAAC;AAEpC,UAAU,8BAA8B;IACtC,iDAAiD;IACjD,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IAC9C,kDAAkD;IAClD,WAAW,EAAE,oBAAoB,EAAE,CAAC;IACpC,+CAA+C;IAC/C,SAAS,EAAE,OAAO,CAAC;IACnB,8CAA8C;IAC9C,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GACpC,8BAA8B,CA8DhC"}