import { A as SetNameAction, B as ZodEnum, D as Reducer, E as RedoAction, G as $ZodTypeInternals, H as ZodObject, K as $strip, M as UndoAction, N as UpgradeManifest, S as PHDocument, U as ZodString, V as ZodLiteral, W as ZodType, _ as NOOPAction, b as PHAuthState, j as SignalDispatch, k as SchemaPruneAction, l as DocumentModelUtils, m as LoadStateAction, o as DocumentModelGlobalState, r as PHDocumentController, t as ActionMap, w as PHDocumentState, x as PHBaseState, z as ZodAny } from "../../index-otPBmxzq.js";
import { $ as WithdrawRfcInput, A as FileDisputeInput, B as ProposeRfcInput, C as AppealDisputeInput, D as DisputeKind, E as Dispute, F as MakeEmpty, G as RecordPublisherDecisionInput, H as PublisherDecision, I as MakeMaybe, J as Rfc, K as RejectRfcInput, L as MakeOptional, M as ImplementRfcInput, N as Incremental, O as DisputeStatus, P as InputMaybe, Q as SupersedePolicyInput, R as Maybe, S as GovernancePHState, T as DismissDisputeInput, U as PublisherDecisionKind, V as PublishPolicyInput, W as RatifyRfcInput, X as Scalars, Y as RfcStatus, Z as StartRfcReviewInput, _ as FileDisputeAction, a as GovernanceRfcsAction, b as GovernanceDocument, c as RatifyRfcAction, d as WithdrawRfcAction, f as GovernancePublisherDecisionsAction, g as DismissDisputeAction, h as AssignInvestigatorAction, i as SupersedePolicyAction, j as GovernanceState, k as Exact, l as RejectRfcAction, m as AppealDisputeAction, n as GovernancePoliciesAction, o as ImplementRfcAction, p as RecordPublisherDecisionAction, q as ResolveDisputeInput, r as PublishPolicyAction, s as ProposeRfcAction, t as GovernanceAction, u as StartRfcReviewAction, v as GovernanceDisputesAction, w as AssignInvestigatorInput, x as GovernanceLocalState, y as ResolveDisputeAction, z as Policy } from "../../actions-B0csZEHl.js";
import { t as DocumentDispatch } from "../../index-BmX8nfqX.js";

//#region document-models/governance/v1/gen/document-model.d.ts
declare const documentModel: DocumentModelGlobalState;
declare namespace creators_d_exports {
  export { appealDispute, assignInvestigator, dismissDispute, fileDispute, resolveDispute };
}
declare const fileDispute: (input: FileDisputeInput) => FileDisputeAction;
declare const assignInvestigator: (input: AssignInvestigatorInput) => AssignInvestigatorAction;
declare const resolveDispute: (input: ResolveDisputeInput) => ResolveDisputeAction;
declare const dismissDispute: (input: DismissDisputeInput) => DismissDisputeAction;
declare const appealDispute: (input: AppealDisputeInput) => AppealDisputeAction;
declare namespace creators_d_exports$2 {
  export { recordPublisherDecision };
}
declare const recordPublisherDecision: (input: RecordPublisherDecisionInput) => RecordPublisherDecisionAction;
declare namespace creators_d_exports$3 {
  export { implementRfc, proposeRfc, ratifyRfc, rejectRfc, startRfcReview, withdrawRfc };
}
declare const proposeRfc: (input: ProposeRfcInput) => ProposeRfcAction;
declare const startRfcReview: (input: StartRfcReviewInput) => StartRfcReviewAction;
declare const ratifyRfc: (input: RatifyRfcInput) => RatifyRfcAction;
declare const implementRfc: (input: ImplementRfcInput) => ImplementRfcAction;
declare const rejectRfc: (input: RejectRfcInput) => RejectRfcAction;
declare const withdrawRfc: (input: WithdrawRfcInput) => WithdrawRfcAction;
declare namespace creators_d_exports$1 {
  export { publishPolicy, supersedePolicy };
}
declare const publishPolicy: (input: PublishPolicyInput) => PublishPolicyAction;
declare const supersedePolicy: (input: SupersedePolicyInput) => SupersedePolicyAction;
//#endregion
//#region document-models/governance/v1/gen/ph-factories.d.ts
declare function defaultGlobalState(): GovernanceState;
declare function defaultLocalState(): GovernanceLocalState;
declare function defaultPHState(): GovernancePHState;
declare function createState(baseState?: Partial<PHBaseState>, globalState?: Partial<GovernanceState>, localState?: Partial<GovernanceLocalState>): GovernancePHState;
/**
 * Creates a GovernanceDocument with custom global and local state
 * This properly handles the PHBaseState requirements while allowing
 * document-specific state to be set.
 */
declare function createGovernanceDocument(state?: Partial<{
  auth?: Partial<PHAuthState>;
  document?: Partial<PHDocumentState>;
  global?: Partial<GovernanceState>;
  local?: Partial<GovernanceLocalState>;
}>): GovernanceDocument;
//#endregion
//#region document-models/governance/v1/gen/utils.d.ts
declare const initialGlobalState: GovernanceState;
declare const initialLocalState: GovernanceLocalState;
//#endregion
//#region document-models/governance/v1/gen/reducer.d.ts
declare const reducer: Reducer<GovernancePHState>;
//#endregion
//#region document-models/governance/v1/gen/controller.d.ts
declare const GovernanceController: new (initialDocument?: PHDocument<GovernancePHState> | undefined) => PHDocumentController<GovernancePHState> & ActionMap<GovernanceAction, PHDocumentController<GovernancePHState>>;
//#endregion
//#region document-models/governance/v1/gen/schema/zod.d.ts
type Properties<T> = Required<{ [K in keyof T]: ZodType<T[K]> }>;
type definedNonNullAny = {};
declare const isDefinedNonNullAny: (v: any) => v is definedNonNullAny;
declare const definedNonNullAnySchema: ZodAny & ZodType<definedNonNullAny, any, $ZodTypeInternals<definedNonNullAny, any>>;
declare const DisputeKindSchema: ZodEnum<{
  OTHER: "OTHER";
  DUPLICATE_CLAIM: "DUPLICATE_CLAIM";
  INACCURATE_ENTRY: "INACCURATE_ENTRY";
  POLICY_VIOLATION: "POLICY_VIOLATION";
  PUBLISHER_CONDUCT: "PUBLISHER_CONDUCT";
  REVIEW_DECISION: "REVIEW_DECISION";
}>;
declare const DisputeStatusSchema: ZodEnum<{
  OPEN: "OPEN";
  APPEALED: "APPEALED";
  DISMISSED: "DISMISSED";
  INVESTIGATING: "INVESTIGATING";
  RESOLVED: "RESOLVED";
}>;
declare const PublisherDecisionKindSchema: ZodEnum<{
  APPROVED: "APPROVED";
  REINSTATED: "REINSTATED";
  REVOKED: "REVOKED";
  SUSPENDED: "SUSPENDED";
}>;
declare const RfcStatusSchema: ZodEnum<{
  REJECTED: "REJECTED";
  UNDER_REVIEW: "UNDER_REVIEW";
  WITHDRAWN: "WITHDRAWN";
  IMPLEMENTED: "IMPLEMENTED";
  PROPOSED: "PROPOSED";
  RATIFIED: "RATIFIED";
}>;
declare function AppealDisputeInputSchema(): ZodObject<Properties<AppealDisputeInput>>;
declare function AssignInvestigatorInputSchema(): ZodObject<Properties<AssignInvestigatorInput>>;
declare function DismissDisputeInputSchema(): ZodObject<Properties<DismissDisputeInput>>;
declare function DisputeSchema(): ZodObject<Properties<Dispute>>;
declare function FileDisputeInputSchema(): ZodObject<Properties<FileDisputeInput>>;
declare function GovernanceStateSchema(): ZodObject<Properties<GovernanceState>>;
declare function ImplementRfcInputSchema(): ZodObject<Properties<ImplementRfcInput>>;
declare function PolicySchema(): ZodObject<Properties<Policy>>;
declare function ProposeRfcInputSchema(): ZodObject<Properties<ProposeRfcInput>>;
declare function PublishPolicyInputSchema(): ZodObject<Properties<PublishPolicyInput>>;
declare function PublisherDecisionSchema(): ZodObject<Properties<PublisherDecision>>;
declare function RatifyRfcInputSchema(): ZodObject<Properties<RatifyRfcInput>>;
declare function RecordPublisherDecisionInputSchema(): ZodObject<Properties<RecordPublisherDecisionInput>>;
declare function RejectRfcInputSchema(): ZodObject<Properties<RejectRfcInput>>;
declare function ResolveDisputeInputSchema(): ZodObject<Properties<ResolveDisputeInput>>;
declare function RfcSchema(): ZodObject<Properties<Rfc>>;
declare function StartRfcReviewInputSchema(): ZodObject<Properties<StartRfcReviewInput>>;
declare function SupersedePolicyInputSchema(): ZodObject<Properties<SupersedePolicyInput>>;
declare function WithdrawRfcInputSchema(): ZodObject<Properties<WithdrawRfcInput>>;
//#endregion
//#region document-models/governance/v1/gen/document-type.d.ts
declare const governanceDocumentType = "rfp-hub/governance";
//#endregion
//#region document-models/governance/v1/gen/document-schema.d.ts
/** Schema for validating the header object of a Governance document */
declare const GovernanceDocumentHeaderSchema: ZodObject<{
  id: ZodString;
  name: ZodString;
  createdAtUtcIso: ZodString;
  lastModifiedAtUtcIso: ZodString;
  documentType: ZodLiteral<"rfp-hub/governance">;
}, $strip>;
/** Schema for validating the state object of a Governance document */
declare const GovernancePHStateSchema: ZodObject<{
  global: ZodObject<Required<{
    disputes: ZodType<Dispute[], unknown, $ZodTypeInternals<Dispute[], unknown>>;
    policies: ZodType<Policy[], unknown, $ZodTypeInternals<Policy[], unknown>>;
    publisherDecisions: ZodType<PublisherDecision[], unknown, $ZodTypeInternals<PublisherDecision[], unknown>>;
    rfcs: ZodType<Rfc[], unknown, $ZodTypeInternals<Rfc[], unknown>>;
  }>, $strip>;
}, $strip>;
declare const GovernanceDocumentSchema: ZodObject<{
  header: ZodObject<{
    id: ZodString;
    name: ZodString;
    createdAtUtcIso: ZodString;
    lastModifiedAtUtcIso: ZodString;
    documentType: ZodLiteral<"rfp-hub/governance">;
  }, $strip>;
  state: ZodObject<{
    global: ZodObject<Required<{
      disputes: ZodType<Dispute[], unknown, $ZodTypeInternals<Dispute[], unknown>>;
      policies: ZodType<Policy[], unknown, $ZodTypeInternals<Policy[], unknown>>;
      publisherDecisions: ZodType<PublisherDecision[], unknown, $ZodTypeInternals<PublisherDecision[], unknown>>;
      rfcs: ZodType<Rfc[], unknown, $ZodTypeInternals<Rfc[], unknown>>;
    }>, $strip>;
  }, $strip>;
  initialState: ZodObject<{
    global: ZodObject<Required<{
      disputes: ZodType<Dispute[], unknown, $ZodTypeInternals<Dispute[], unknown>>;
      policies: ZodType<Policy[], unknown, $ZodTypeInternals<Policy[], unknown>>;
      publisherDecisions: ZodType<PublisherDecision[], unknown, $ZodTypeInternals<PublisherDecision[], unknown>>;
      rfcs: ZodType<Rfc[], unknown, $ZodTypeInternals<Rfc[], unknown>>;
    }>, $strip>;
  }, $strip>;
}, $strip>;
/** Simple helper function to check if a state object is a Governance document state object */
declare function isGovernanceState(state: unknown): state is GovernancePHState;
/** Simple helper function to assert that a document state object is a Governance document state object */
declare function assertIsGovernanceState(state: unknown): asserts state is GovernancePHState;
/** Simple helper function to check if a document is a Governance document */
declare function isGovernanceDocument(document: unknown): document is GovernanceDocument;
/** Simple helper function to assert that a document is a Governance document */
declare function assertIsGovernanceDocument(document: unknown): asserts document is GovernanceDocument;
//#endregion
//#region document-models/governance/v1/gen/disputes/operations.d.ts
interface GovernanceDisputesOperations {
  fileDisputeOperation: (state: GovernanceState, action: FileDisputeAction, dispatch?: SignalDispatch) => void;
  assignInvestigatorOperation: (state: GovernanceState, action: AssignInvestigatorAction, dispatch?: SignalDispatch) => void;
  resolveDisputeOperation: (state: GovernanceState, action: ResolveDisputeAction, dispatch?: SignalDispatch) => void;
  dismissDisputeOperation: (state: GovernanceState, action: DismissDisputeAction, dispatch?: SignalDispatch) => void;
  appealDisputeOperation: (state: GovernanceState, action: AppealDisputeAction, dispatch?: SignalDispatch) => void;
}
//#endregion
//#region document-models/governance/v1/gen/publisher-decisions/operations.d.ts
interface GovernancePublisherDecisionsOperations {
  recordPublisherDecisionOperation: (state: GovernanceState, action: RecordPublisherDecisionAction, dispatch?: SignalDispatch) => void;
}
//#endregion
//#region document-models/governance/v1/gen/rfcs/operations.d.ts
interface GovernanceRfcsOperations {
  proposeRfcOperation: (state: GovernanceState, action: ProposeRfcAction, dispatch?: SignalDispatch) => void;
  startRfcReviewOperation: (state: GovernanceState, action: StartRfcReviewAction, dispatch?: SignalDispatch) => void;
  ratifyRfcOperation: (state: GovernanceState, action: RatifyRfcAction, dispatch?: SignalDispatch) => void;
  implementRfcOperation: (state: GovernanceState, action: ImplementRfcAction, dispatch?: SignalDispatch) => void;
  rejectRfcOperation: (state: GovernanceState, action: RejectRfcAction, dispatch?: SignalDispatch) => void;
  withdrawRfcOperation: (state: GovernanceState, action: WithdrawRfcAction, dispatch?: SignalDispatch) => void;
}
//#endregion
//#region document-models/governance/v1/gen/policies/operations.d.ts
interface GovernancePoliciesOperations {
  publishPolicyOperation: (state: GovernanceState, action: PublishPolicyAction, dispatch?: SignalDispatch) => void;
  supersedePolicyOperation: (state: GovernanceState, action: SupersedePolicyAction, dispatch?: SignalDispatch) => void;
}
//#endregion
//#region document-models/governance/v1/hooks.d.ts
/** Hook to get a Governance document by its id */
declare function useGovernanceDocumentById(documentId: string | null | undefined): [GovernanceDocument, DocumentDispatch<GovernanceAction>] | [undefined, undefined];
/** Hook to get the selected Governance document */
declare function useSelectedGovernanceDocument(): [GovernanceDocument, DocumentDispatch<GovernanceAction>];
/** Hook to get all Governance documents in the selected drive */
declare function useGovernanceDocumentsInSelectedDrive(): GovernanceDocument[] | undefined;
/** Hook to get all Governance documents in the selected folder */
declare function useGovernanceDocumentsInSelectedFolder(): GovernanceDocument[] | undefined;
//#endregion
//#region document-models/governance/v1/actions.d.ts
/** Actions for the Governance document model */
declare const actions: {
  publishPolicy: (input: PublishPolicyInput) => PublishPolicyAction;
  supersedePolicy: (input: SupersedePolicyInput) => SupersedePolicyAction;
  proposeRfc: (input: ProposeRfcInput) => ProposeRfcAction;
  startRfcReview: (input: StartRfcReviewInput) => StartRfcReviewAction;
  ratifyRfc: (input: RatifyRfcInput) => RatifyRfcAction;
  implementRfc: (input: ImplementRfcInput) => ImplementRfcAction;
  rejectRfc: (input: RejectRfcInput) => RejectRfcAction;
  withdrawRfc: (input: WithdrawRfcInput) => WithdrawRfcAction;
  recordPublisherDecision: (input: RecordPublisherDecisionInput) => RecordPublisherDecisionAction;
  fileDispute: (input: FileDisputeInput) => FileDisputeAction;
  assignInvestigator: (input: AssignInvestigatorInput) => AssignInvestigatorAction;
  resolveDispute: (input: ResolveDisputeInput) => ResolveDisputeAction;
  dismissDispute: (input: DismissDisputeInput) => DismissDisputeAction;
  appealDispute: (input: AppealDisputeInput) => AppealDisputeAction;
  setName: (name: string | {
    name: string;
  }) => SetNameAction;
  undo: (count?: number, scope?: string) => UndoAction;
  redo: (count?: number, scope?: string) => RedoAction;
  prune: (start?: number, end?: number, scope?: string) => SchemaPruneAction;
  loadState: <TState extends PHBaseState = PHBaseState>(state: TState & {
    name: string;
  }, operations: number) => LoadStateAction;
  noop: (scope?: string) => NOOPAction;
};
//#endregion
//#region document-models/governance/v1/utils.d.ts
/** Utils for the Governance document model */
declare const utils: DocumentModelUtils<GovernancePHState>;
//#endregion
//#region document-models/governance/upgrades/versions.d.ts
declare const supportedVersions: readonly [1];
declare const latestVersion: 1;
//#endregion
//#region document-models/governance/upgrades/upgrade-manifest.d.ts
declare const governanceUpgradeManifest: UpgradeManifest<typeof supportedVersions>;
//#endregion
export { AppealDisputeAction, AppealDisputeInput, AppealDisputeInputSchema, AssignInvestigatorAction, AssignInvestigatorInput, AssignInvestigatorInputSchema, DismissDisputeAction, DismissDisputeInput, DismissDisputeInputSchema, Dispute, DisputeKind, DisputeKindSchema, DisputeSchema, DisputeStatus, DisputeStatusSchema, Exact, FileDisputeAction, FileDisputeInput, FileDisputeInputSchema, GovernanceAction, GovernanceController, GovernanceDisputesAction, GovernanceDisputesOperations, GovernanceDocument, GovernanceDocumentHeaderSchema, GovernanceDocumentSchema, GovernanceState as GovernanceGlobalState, GovernanceState, GovernanceLocalState, GovernancePHState, GovernancePHStateSchema, GovernancePoliciesAction, GovernancePoliciesOperations, GovernancePublisherDecisionsAction, GovernancePublisherDecisionsOperations, GovernanceRfcsAction, GovernanceRfcsOperations, GovernanceStateSchema, ImplementRfcAction, ImplementRfcInput, ImplementRfcInputSchema, Incremental, InputMaybe, MakeEmpty, MakeMaybe, MakeOptional, Maybe, Policy, PolicySchema, ProposeRfcAction, ProposeRfcInput, ProposeRfcInputSchema, PublishPolicyAction, PublishPolicyInput, PublishPolicyInputSchema, PublisherDecision, PublisherDecisionKind, PublisherDecisionKindSchema, PublisherDecisionSchema, RatifyRfcAction, RatifyRfcInput, RatifyRfcInputSchema, RecordPublisherDecisionAction, RecordPublisherDecisionInput, RecordPublisherDecisionInputSchema, RejectRfcAction, RejectRfcInput, RejectRfcInputSchema, ResolveDisputeAction, ResolveDisputeInput, ResolveDisputeInputSchema, Rfc, RfcSchema, RfcStatus, RfcStatusSchema, Scalars, StartRfcReviewAction, StartRfcReviewInput, StartRfcReviewInputSchema, SupersedePolicyAction, SupersedePolicyInput, SupersedePolicyInputSchema, WithdrawRfcAction, WithdrawRfcInput, WithdrawRfcInputSchema, actions, appealDispute, assertIsGovernanceDocument, assertIsGovernanceState, assignInvestigator, createGovernanceDocument, createState, defaultGlobalState, defaultLocalState, defaultPHState, definedNonNullAnySchema, dismissDispute, documentModel, fileDispute, creators_d_exports as governanceDisputesActions, governanceDocumentType, creators_d_exports$1 as governancePoliciesActions, creators_d_exports$2 as governancePublisherDecisionsActions, creators_d_exports$3 as governanceRfcsActions, governanceUpgradeManifest, implementRfc, initialGlobalState, initialLocalState, isDefinedNonNullAny, isGovernanceDocument, isGovernanceState, latestVersion, proposeRfc, publishPolicy, ratifyRfc, recordPublisherDecision, reducer, rejectRfc, resolveDispute, startRfcReview, supersedePolicy, supportedVersions, useGovernanceDocumentById, useGovernanceDocumentsInSelectedDrive, useGovernanceDocumentsInSelectedFolder, useSelectedGovernanceDocument, utils, withdrawRfc };
//# sourceMappingURL=index.d.ts.map