import { A as Action, D as DocumentFile, a as Document, B as BaseAction, F as FileInput, b as BaseDocument, S as SetNameAction, U as UndoAction, R as RedoAction, P as PruneAction, L as LoadStateAction } from './file-419fc117.js';

declare const SUBMIT_FOR_REVIEW = "SUBMIT_FOR_REVIEW";
declare const ESCALATE = "ESCALATE";
declare const APPROVE = "APPROVE";
declare const REOPEN_TO_DRAFT = "REOPEN_TO_DRAFT";
declare const REOPEN_TO_REVIEW = "REOPEN_TO_REVIEW";
interface SubmitForReviewAction extends Action {
    type: typeof SUBMIT_FOR_REVIEW;
}
interface EscalateAction extends Action {
    type: typeof ESCALATE;
}
interface ApproveAction extends Action {
    type: typeof APPROVE;
}
interface ReopenToDraftAction extends Action {
    type: typeof REOPEN_TO_DRAFT;
}
interface ReopenToReviewAction extends Action {
    type: typeof REOPEN_TO_REVIEW;
}
type BudgetStatementStatusAction = SubmitForReviewAction | EscalateAction | ApproveAction | ReopenToDraftAction | ReopenToReviewAction;

declare const ADD_ACCOUNT = "ADD_ACCOUNT";
declare const UPDATE_ACCOUNT = "UPDATE_ACCOUNT";
declare const DELETE_ACCOUNT = "DELETE_ACCOUNT";
interface AddAccountAction extends Action {
    type: typeof ADD_ACCOUNT;
    input: {
        accounts: AccountInput[];
    };
}
interface UpdateAccountAction extends Action {
    type: typeof UPDATE_ACCOUNT;
    input: {
        accounts: AccountInput[];
    };
}
interface DeleteAccountAction extends Action {
    type: typeof DELETE_ACCOUNT;
    input: {
        accounts: Account['address'][];
    };
}
type BudgetStatementAccountAction = AddAccountAction | UpdateAccountAction | DeleteAccountAction;

declare const ADD_AUDIT_REPORT = "ADD_AUDIT_REPORT";
declare const DELETE_AUDIT_REPORT = "DELETE_AUDIT_REPORT";
interface AddAuditReportAction extends Action {
    type: typeof ADD_AUDIT_REPORT;
    input: {
        reports: (AuditReportInput | AuditReport)[];
    };
}
interface DeleteAuditReportAction extends Action {
    type: typeof DELETE_AUDIT_REPORT;
    input: {
        reports: AuditReport['report'][];
    };
}
type BudgetStatementAuditReportAction = AddAuditReportAction | DeleteAuditReportAction;

declare const ADD_COMMENT = "ADD_COMMENT";
declare const UPDATE_COMMENT = "UPDATE_COMMENT";
declare const DELETE_COMMENT = "DELETE_COMMENT";
interface AddCommentAction extends Action {
    type: typeof ADD_COMMENT;
    input: {
        comments: Partial<Comment>[];
    };
}
interface UpdateCommentAction extends Action {
    type: typeof UPDATE_COMMENT;
    input: {
        comments: CommentInput[];
    };
}
interface DeleteCommentAction extends Action {
    type: typeof DELETE_COMMENT;
    input: {
        comments: Comment['key'][];
    };
}
type BudgetStatementCommentAction = AddCommentAction | UpdateCommentAction | DeleteCommentAction;

declare const INIT = "INIT";
interface InitAction extends Action {
    type: typeof INIT;
    input: Partial<Omit<BudgetStatementDocument, 'data'> & {
        data: Partial<BudgetStatementDocument['data']>;
    }>;
}
type BudgetStatementInitAction = InitAction;

declare const ADD_VESTING = "ADD_VESTING";
declare const UPDATE_VESTING = "UPDATE_VESTING";
declare const DELETE_VESTING = "DELETE_VESTING";
interface AddVestingAction extends Action {
    type: typeof ADD_VESTING;
    input: {
        vesting: Partial<Vesting>[];
    };
}
interface UpdateVestingAction extends Action {
    type: typeof UPDATE_VESTING;
    input: {
        vesting: VestingInput[];
    };
}
interface DeleteVestingAction extends Action {
    type: typeof DELETE_VESTING;
    input: {
        vesting: Vesting['key'][];
    };
}
type BudgetStatementVestingAction = AddVestingAction | UpdateVestingAction | DeleteVestingAction;

/**
 * Represents an expense item for a specific account.
 */
type LineItem = {
    /** The reference to the group of the expense. */
    group: {
        ref: string;
        id: string;
        title: string;
    };
    /** If the expense is related to the headcount. */
    headcountExpense: boolean;
    /** The reference to the category of the expense. */
    category: {
        ref: string;
        id: string;
        title: string;
    };
    /** The budget cap for the expense. */
    budgetCap: number | null;
    /** The actual value of the expense. */
    actual: number | null;
    /** The payment done to the wallet in that month. */
    payment: number | null;
    /** The forecast for the next 3 months for that expense. */
    forecast: {
        month: string;
        value: number;
        budgetCap: number;
    }[];
    comment: string | null;
};
/**
 * Represents the input for creating or updating a line item.
 *
 * @remarks
 * The only necessary attributes are the category and the group
 * as they are used to identify the line item.
 */
type LineItemInput = Partial<Omit<LineItem, 'category' | 'group'>> & {
    /** The reference to the category of the expense. */
    category: string;
    /** The reference to the group of the expense. */
    group: string;
};
/**
 * Represents an account for which expenses are managed in a budget statement.
 */
type Account = {
    /** The wallet address associated with the account. */
    address: string;
    /** The name of the account. */
    name: string;
    /** The line items associated with the account. */
    lineItems: LineItem[];
};
/**
 * Represents the input for creating or updating an account.
 * @remarks
 * The only necessary attribute is the account address,
 * as it is an unique attribute used to identify the account.
 */
type AccountInput = Partial<Account> & Pick<Account, 'address'>;
/**
 * Represents the status of the budget statement: 'Draft', 'Review', 'Final', or 'Escalated'.
 */
type BudgetStatus = 'Draft' | 'Review' | 'Final' | 'Escalated';
/**
 * Represents the status of an audit report: 'Approved', 'ApprovedWithComments', 'NeedsAction', or 'Escalated'.
 */
type AuditReportStatus = 'Approved' | 'ApprovedWithComments' | 'NeedsAction' | 'Escalated';
/**
 * A string literal type representing the format for attaching audit reports to a budget statement.
 */
type AuditAttachment = `attachment://audits/${string}`;
/**
 * Represents an audit report for a budget statement.
 */
type AuditReport = {
    /** The timestamp of the audit report. */
    timestamp: string;
    /** The attachment for the audit report. */
    report: AuditAttachment;
    /** The status of the audit report. */
    status: AuditReportStatus;
};
/**
 * Represents the input for an audit report to be added to a budget statement.
 */
type AuditReportInput = {
    /**
     * The timestamp for the audit report.
     */
    timestamp: string;
    /**
     * The data for the audit report.
     */
    report: DocumentFile;
    /**
     * The status of the audit report.
     */
    status: AuditReportStatus;
};
type Comment = {
    key: string;
    author: {
        ref: string | null;
        id: string | null;
        username: string | null;
        roleLabel: string | null;
    };
    comment: string;
    timestamp: string;
};
type VestingInput = Partial<Omit<Vesting, 'key'>> & {
    key: Vesting['key'];
};
type Vesting = {
    key: string;
    date: string;
    amount: string;
    amountOld: string;
    comment: string;
    currency: string;
    vested: boolean;
};
type CommentInput = Partial<Omit<Comment, 'key'>> & {
    key: Comment['key'];
};
type FTEs = {
    value: string;
    forecast: {
        month: string;
        value: number;
    }[];
};
/**
 * Represents the state of a budget statement.
 */
type State = {
    /**
     * A reference to the owner of the budget statement.
     */
    owner: {
        ref: string | null;
        id: string | null;
        title: string | null;
    };
    /**
     * The month that the budget statement refers to.
     */
    month: string | null;
    /**
     * The status of the budget statement.
     */
    status: BudgetStatus;
    /**
     * The quote currency for the budget statement.
     */
    quoteCurrency: string | null;
    vesting: Vesting[];
    ftes: FTEs | null;
    /**
     * The list of accounts in the budget statement.
     */
    accounts: Account[];
    /**
     * The list of audit reports for the budget statement.
     */
    auditReports: AuditReport[];
    comments: Comment[];
};
/**
 * Represents the possible actions that can be performed on a budget statement.
 */
type BudgetStatementAction = BudgetStatementAccountAction | BudgetStatementInitAction | BudgetStatementLineItemAction | BudgetStatementStatusAction | BudgetStatementAuditReportAction | BudgetStatementVestingAction | BudgetStatementCommentAction;
/**
 * Represents a budget statement document, which extends the base Document type.
 */
type BudgetStatementDocument = Document<State, BudgetStatementAction>;

/**
 * Reducer for the BudgetStatement module, which handles operations related to budget statements.
 * @remarks
 * This reducer handles the following actions:
 * - `INIT`: initializes the state of the module.
 * - `ADD_ACCOUNT`: adds an account to the state.
 * - `UPDATE_ACCOUNT`: updates an account in the state.
 * - `DELETE_ACCOUNT`: removes an account from the state.
 * - `ADD_LINE_ITEM`: adds a line item to an account in the state.
 * - `UPDATE_LINE_ITEM`: updates a line item in an account in the state.
 * - `DELETE_LINE_ITEM`: removes a line item from an account in the state.
 * - `SUBMIT_FOR_REVIEW`: updates the status of the budget statement to "Under Review".
 * - `ESCALATE`: escalates the budget statement to a higher authority.
 * - `APPROVE`: approves the budget statement.
 * - `REOPEN_TO_DRAFT`: changes the status of the budget statement to "Draft".
 * - `REOPEN_TO_REVIEW`: changes the status of the budget statement to "Under Review".
 * - `ADD_AUDIT_REPORT`: adds an audit report to an account in the state.
 * - `DELETE_AUDIT_REPORT`: removes an audit report from an account in the state.
 * @param state - The current state of the module.
 * @param action - The action to be performed on the state.
 * @returns The new state after applying the action.
 */
declare const reducer: (state: Document<State, BaseAction | BudgetStatementAction>, action: BaseAction | BudgetStatementAction) => Document<State, BudgetStatementAction>;

/**
 *
 * Creates a new BudgetStatement document with an initial state.
 * @param initialState - The initial state of the document.
 * @returns The new BudgetStatement document.
 */
declare const createBudgetStatement: (initialState?: Partial<Omit<BudgetStatementDocument, 'data'> & {
    data: Partial<BudgetStatementDocument['data']>;
}>) => BudgetStatementDocument;
/**
 * Creates a new Account with default properties and the given input properties.
 * @param input - The input properties of the account.
 * @returns The new Account object.
 */
declare const createAccount: (input: AccountInput) => Account;
/**
 * Creates a new LineItem with default properties and the given input properties.
 * @param input - The input properties of the line item.
 * @returns The new LineItem object.
 */
declare const createLineItem: (input: Partial<LineItem> & Pick<LineItem, 'category' | 'group'>) => LineItem;
/**
 * Saves the BudgetStatement document to the specified file path.
 * @param document - The BudgetStatement document to save.
 * @param path - The file path to save the document to.
 * @returns  A promise that resolves with the saved file path.
 */
declare const saveBudgetStatementToFile: (document: BudgetStatementDocument, path: string, name?: string) => Promise<string>;
/**
 * Loads the BudgetStatement document from the specified file path.
 * @param path - The file path to load the document from.
 * @returns A promise that resolves with the loaded BudgetStatement document.
 */
declare const loadBudgetStatementFromFile: (path: string) => Promise<BudgetStatementDocument>;
declare const loadBudgetStatementFromInput: (input: FileInput) => Promise<BudgetStatementDocument>;
declare const saveBudgetStatementToFileHandle: (document: BudgetStatementDocument, input: FileSystemFileHandle) => Promise<void>;

declare const utils_createAccount: typeof createAccount;
declare const utils_createBudgetStatement: typeof createBudgetStatement;
declare const utils_createLineItem: typeof createLineItem;
declare const utils_loadBudgetStatementFromFile: typeof loadBudgetStatementFromFile;
declare const utils_loadBudgetStatementFromInput: typeof loadBudgetStatementFromInput;
declare const utils_saveBudgetStatementToFile: typeof saveBudgetStatementToFile;
declare const utils_saveBudgetStatementToFileHandle: typeof saveBudgetStatementToFileHandle;
declare namespace utils {
  export {
    utils_createAccount as createAccount,
    utils_createBudgetStatement as createBudgetStatement,
    utils_createLineItem as createLineItem,
    utils_loadBudgetStatementFromFile as loadBudgetStatementFromFile,
    utils_loadBudgetStatementFromInput as loadBudgetStatementFromInput,
    utils_saveBudgetStatementToFile as saveBudgetStatementToFile,
    utils_saveBudgetStatementToFileHandle as saveBudgetStatementToFileHandle,
  };
}

declare const ADD_LINE_ITEM = "ADD_LINE_ITEM";
declare const UPDATE_LINE_ITEM = "UPDATE_LINE_ITEM";
declare const DELETE_LINE_ITEM = "DELETE_LINE_ITEM";
interface AddLineItemAction extends Action {
    type: typeof ADD_LINE_ITEM;
    input: {
        account: Account['address'];
        lineItems: (Partial<LineItem> & Pick<LineItem, 'category' | 'group'>)[];
    };
}
interface UpdateLineItemAction extends Action {
    type: typeof UPDATE_LINE_ITEM;
    input: {
        account: Account['address'];
        lineItems: LineItemInput[];
    };
}
interface DeleteLineItemAction extends Action {
    type: typeof DELETE_LINE_ITEM;
    input: {
        account: Account['address'];
        lineItems: {
            category: string;
            group: string;
        }[];
    };
}
type BudgetStatementLineItemAction = AddLineItemAction | UpdateLineItemAction | DeleteLineItemAction;

/**
 * Account related methods and getters
 */
declare class AccountObject extends BaseDocument<State, BudgetStatementAction> {
    /**
     * Adds one or more accounts to the budget statement.
     * @param accounts An array of AccountInput objects to add.
     *
     * @group Account
     */
    addAccount(accounts: AccountInput[]): this;
    /**
     * Updates one or more existing accounts in the budget statement.
     * @param accounts An array of AccountInput objects to update.
     *
     * @group Account
     */
    updateAccount(accounts: AccountInput[]): this;
    /**
     * Deletes one or more accounts from the budget statement.
     * @param addresses An array of addresses of the accounts to delete.
     *
     * @group Account
     */
    deleteAccount(accounts: Account['address'][]): this;
    /**
     * Returns an array of all accounts in the budget statement.
     *
     * @group Account
     */
    get accounts(): Account[];
    /**
     * Returns the Account object with the specified address.
     * @param address The address of the Account to retrieve.
     *
     * @group Account
     */
    getAccount(address: Account['address']): Account | undefined;
}

declare class AuditObject extends BaseDocument<State, BudgetStatementAction> {
    /**
     * Adds audit reports to the budget statement.
     * @param reports - An array of audit report objects to add.
     *
     * @group Audit
     */
    addAuditReport(reports: {
        timestamp?: string;
        status: AuditReportStatus;
        report: DocumentFile;
    }[]): this;
    /**
     * Deletes audit reports from the budget statement.
     * @param reports - An array of objects that contain the report attachment name of the audits items to be deleted.
     *
     * @group Audit
     */
    deleteAuditReport(reports: AuditReport['report'][]): this;
    /**
     * Retrieves all audit reports from the budget statement.
     * @returns An array of audit report objects.
     *
     * @group Audit
     */
    getAuditReports(): AuditReport[];
    /**
     * Retrieves a specific audit report from the budget statement.
     * @param report - The name of the attachment of the report to be retrieved.
     * @returns The audit report object if it exists, or undefined if not.
     *
     * @group Audit
     */
    getAuditReport(report: AuditReport['report']): AuditReport | undefined;
}

declare class CommentObject extends BaseDocument<State, BudgetStatementAction> {
    addComment(comments: Partial<Comment>[]): this;
    updateComment(comments: CommentInput[]): this;
    deleteComment(comments: string[]): this;
}

declare class InitObject extends BaseDocument<State, BudgetStatementAction> {
    /**
     * Initializes the state of the budget statement with the provided partial object.
     *
     * @param budgetStatement - A partial object of the budget statement to initialize.
     */
    init(budgetStatement: Partial<Omit<BudgetStatementDocument, 'data'> & {
        data: Partial<BudgetStatementDocument['data']>;
    }>): this;
}

declare class LineItemObject extends BaseDocument<State, BudgetStatementAction> {
    /**
     * Adds a line item to the specified account.
     * @param account The address of the account to which the line item will be added.
     * @param lineItems An array of line item objects to be added to the account.
     *
     * @group Line Item
     */
    addLineItem(account: Account['address'], lineItems: (Partial<LineItem> & Pick<LineItem, 'category' | 'group'>)[]): this;
    /**
     * Updates line items for the specified account.
     * @param account The address of the account for which line items will be updated.
     * @param lineItems An array of line item input objects to be updated.
     *
     * @group Line Item
     */
    updateLineItem(account: Account['address'], lineItems: LineItemInput[]): this;
    /**
     * Deletes line items for the specified account.
     * @param account The address of the account for which line items will be deleted.
     * @param lineItems An array of objects that contain the category and group of the line items to be deleted.
     *
     * @group Line Item
     */
    deleteLineItem(account: Account['address'], lineItems: {
        category: string;
        group: string;
    }[]): this;
    /**
     * Retrieves line items for the specified account.
     * @param account The address of the account for which line items will be retrieved.
     * @returns An array of line item objects for the specified account, or undefined if the account does not exist.
     *
     * @group Line Item
     */
    getLineItems(account: Account['address']): LineItem[] | undefined;
    /**
     * Retrieves a specific line item for the specified account.
     * @param account The address of the account for which the line item will be retrieved.
     * @param lineItem An object that contains the category and group of the line item to be retrieved.
     * @returns The line item object that matches the specified category and group, or undefined if it does not exist.
     *
     * @group Line Item
     */
    getLineItem(account: Account['address'], lineItem: {
        category: string;
        group: string;
    }): LineItem | undefined;
}

declare class StatusObject extends BaseDocument<State, BudgetStatementAction> {
    /**
     * Submits the budget statement for review.
     *
     * @group Status
     */
    submitForReview(): this;
    /**
     * Escalates the budget statement.
     *
     * @group Status
     */
    escalate(): this;
    /**
     * Approves the budget statement.
     *
     * @group Status
     */
    approve(): this;
    /**
     * Reopens the budget statement to draft status.
     * @returns A promise that resolves when the action is complete.
     *
     * @group Status
     */
    reopenToDraft(): this;
    /**
     * Reopens the budget statement to review status.
     * @returns A promise that resolves when the action is complete.
     *
     * @group Status
     */
    reopenToReview(): this;
    /**
     * Gets the current status of the budget statement.
     * @returns The status of the budget statement.
     *
     * @group Status
     */
    get status(): BudgetStatus;
}

declare class VestingObject extends BaseDocument<State, BudgetStatementAction> {
    addVesting(vesting: Partial<Vesting>[]): this;
    updateVesting(vesting: VestingInput[]): this;
    deleteVesting(vesting: string[]): this;
}

/**
 * Represents a BudgetStatement object that extends the {@link BaseDocument} class to provide a convenient
 * interface for managing a budget statement.
 */
interface BudgetStatement$2 extends AccountObject, AuditObject, CommentObject, InitObject, LineItemObject, StatusObject, VestingObject {
}
/**
 * Represents a budget statement document.
 *
 * @extends BaseDocument<State, BudgetStatementAction>
 * @module
 */
declare class BudgetStatement$2 extends BaseDocument<State, BudgetStatementAction> {
    /**
     * The file extension used to save budget statements.
     */
    static fileExtension: string;
    /**
     *
     * Creates a new BudgetStatement instance.
     * @param initialState - An optional object representing the initial state of the BudgetStatement.
     */
    constructor(initialState?: Partial<Omit<BudgetStatementDocument, 'data'> & {
        data: Partial<BudgetStatementDocument['data']>;
    }>);
    /**
     * Gets the month of the budget statement.
     * @category Budget Statement
     */
    get month(): string | null;
    /**
     * Gets the owner of the budget statement.
     * @category Budget Statement
     */
    get owner(): {
        ref: string | null;
        id: string | null;
        title: string | null;
    };
    /**
     * Gets the quote currency of the budget statement.
     * @category Budget Statement
     */
    get quoteCurrency(): string | null;
    /**
     * Saves the budget statement to a file.
     *
     * @param path The path to the file to save.
     * @returns A promise that resolves when the save operation completes.
     */
    saveToFile(path: string, name?: string): Promise<string>;
    /**
     * Loads the budget statement from a file.
     *
     * @param path The path to the file to load.
     * @returns A promise that resolves with the loaded `BudgetStatement` instance.
     */
    loadFromFile(path: string): Promise<void>;
    /**
     * Creates a new `BudgetStatement` instance from a file.
     *
     * @param path The path to the file to load.
     * @returns A promise that resolves with the loaded `BudgetStatement` instance.
     */
    static fromFile(path: string): Promise<BudgetStatement$2>;
}

declare const BudgetStatement: typeof BudgetStatement$2;
declare const actions: {
    addAccount: (accounts: AccountInput[]) => AddAccountAction;
    updateAccount: (accounts: AccountInput[]) => UpdateAccountAction;
    deleteAccount: (accounts: string[]) => DeleteAccountAction;
    addAuditReport: (reports: {
        timestamp?: string | undefined;
        status: AuditReportStatus;
        report: DocumentFile;
    }[]) => AddAuditReportAction;
    deleteAuditReport: (reports: `attachment://audits/${string}`[]) => DeleteAuditReportAction;
    init: (budgetStatement: Partial<Omit<BudgetStatementDocument, "data"> & {
        data: Partial<State>;
    }>) => InitAction;
    addLineItem: (account: string, lineItems: (Partial<LineItem> & Pick<LineItem, "category" | "group">)[]) => AddLineItemAction;
    updateLineItem: (account: string, lineItems: LineItemInput[]) => UpdateLineItemAction;
    deleteLineItem: (account: string, lineItems: {
        category: string;
        group: string;
    }[]) => DeleteLineItemAction;
    submitForReview: () => SubmitForReviewAction;
    escalate: () => EscalateAction;
    approve: () => ApproveAction;
    reopenToDraft: () => ReopenToDraftAction;
    reopenToReview: () => ReopenToReviewAction;
    setName: (name: string) => SetNameAction;
    undo: (count?: number) => UndoAction;
    redo: (count?: number) => RedoAction;
    prune: (start?: number | undefined, end?: number | undefined) => PruneAction;
    loadState: (state: Pick<Document<unknown, Action<string>>, "name" | "data">, operations: number) => LoadStateAction;
};

type BudgetStatement$1_Account = Account;
type BudgetStatement$1_AccountInput = AccountInput;
type BudgetStatement$1_AuditAttachment = AuditAttachment;
type BudgetStatement$1_AuditReport = AuditReport;
type BudgetStatement$1_AuditReportInput = AuditReportInput;
type BudgetStatement$1_AuditReportStatus = AuditReportStatus;
declare const BudgetStatement$1_BudgetStatement: typeof BudgetStatement;
type BudgetStatement$1_BudgetStatementAction = BudgetStatementAction;
type BudgetStatement$1_BudgetStatementDocument = BudgetStatementDocument;
type BudgetStatement$1_BudgetStatus = BudgetStatus;
type BudgetStatement$1_Comment = Comment;
type BudgetStatement$1_CommentInput = CommentInput;
type BudgetStatement$1_FTEs = FTEs;
type BudgetStatement$1_LineItem = LineItem;
type BudgetStatement$1_LineItemInput = LineItemInput;
type BudgetStatement$1_State = State;
type BudgetStatement$1_Vesting = Vesting;
type BudgetStatement$1_VestingInput = VestingInput;
declare const BudgetStatement$1_actions: typeof actions;
declare const BudgetStatement$1_reducer: typeof reducer;
declare const BudgetStatement$1_utils: typeof utils;
declare namespace BudgetStatement$1 {
  export {
    BudgetStatement$1_Account as Account,
    BudgetStatement$1_AccountInput as AccountInput,
    BudgetStatement$1_AuditAttachment as AuditAttachment,
    BudgetStatement$1_AuditReport as AuditReport,
    BudgetStatement$1_AuditReportInput as AuditReportInput,
    BudgetStatement$1_AuditReportStatus as AuditReportStatus,
    BudgetStatement$1_BudgetStatement as BudgetStatement,
    BudgetStatement$1_BudgetStatementAction as BudgetStatementAction,
    BudgetStatement$1_BudgetStatementDocument as BudgetStatementDocument,
    BudgetStatement$1_BudgetStatus as BudgetStatus,
    BudgetStatement$1_Comment as Comment,
    BudgetStatement$1_CommentInput as CommentInput,
    BudgetStatement$1_FTEs as FTEs,
    BudgetStatement$1_LineItem as LineItem,
    BudgetStatement$1_LineItemInput as LineItemInput,
    BudgetStatement$1_State as State,
    BudgetStatement$1_Vesting as Vesting,
    BudgetStatement$1_VestingInput as VestingInput,
    BudgetStatement$1_actions as actions,
    BudgetStatement$1_reducer as reducer,
    BudgetStatement$1_utils as utils,
  };
}

export { Account as A, BudgetStatement$1 as B, Comment as C, FTEs as F, LineItem as L, State as S, VestingInput as V, BudgetStatement as a, actions as b, LineItemInput as c, AccountInput as d, BudgetStatus as e, AuditReportStatus as f, AuditAttachment as g, AuditReport as h, AuditReportInput as i, Vesting as j, CommentInput as k, BudgetStatementAction as l, BudgetStatementDocument as m, reducer as r, utils as u };
