@rockrms/obsidian-framework 1.16.3-rc.1

package/types/Utility/aspDateFormat.d.ts

@@ -0,0 +1,9 @@
+import { RockDateTime } from "./rockDateTime";
+/**
+ * Formats the given Date object using nearly the same rules as the ASP C#
+ * format methods.
+ *
+ * @param date The date object to be formatted.
+ * @param format The format string to use.
+ */
+export declare function formatAspDate(date: RockDateTime, format: string): string;

package/types/Utility/block.d.ts

@@ -0,0 +1,186 @@
+import { BlockEvent, InvokeBlockActionFunc, SecurityGrant } from "@Obsidian/Types/Utility/block";
+import { IBlockPersonPreferencesProvider } from "@Obsidian/Types/Core/personPreferences";
+import { ExtendedRef } from "@Obsidian/Types/Utility/component";
+import { Ref } from "vue";
+import { Guid } from "@Obsidian/Types";
+import { HttpPostFunc } from "@Obsidian/Types/Utility/http";
+/**
+ * Maps the block configuration values to the expected type.
+ *
+ * @returns The configuration values for the block.
+ */
+export declare function useConfigurationValues<T>(): T;
+/**
+ * Gets the function that will be used to invoke block actions.
+ *
+ * @returns An instance of @see {@link InvokeBlockActionFunc}.
+ */
+export declare function useInvokeBlockAction(): InvokeBlockActionFunc;
+/**
+ * Creates a function that can be provided to the block that allows calling
+ * block actions.
+ *
+ * @private This should not be used by plugins.
+ *
+ * @param post The function to handle the post operation.
+ * @param pageGuid The unique identifier of the page.
+ * @param blockGuid The unique identifier of the block.
+ * @param pageParameters The parameters to include with the block action calls.
+ *
+ * @returns A function that can be used to provide the invoke block action.
+ */
+export declare function createInvokeBlockAction(post: HttpPostFunc, pageGuid: Guid, blockGuid: Guid, pageParameters: Record<string, string>): InvokeBlockActionFunc;
+/**
+ * Provides the reload block callback function for a block. This is an internal
+ * method and should not be used by plugins.
+ *
+ * @param callback The callback that will be called when a block wants to reload itself.
+ */
+export declare function provideReloadBlock(callback: () => void): void;
+/**
+ * Gets a function that can be called when a block wants to reload itself.
+ *
+ * @returns A function that will cause the block component to be reloaded.
+ */
+export declare function useReloadBlock(): () => void;
+/**
+ * Provides the data for a block to be notified when its configuration values
+ * have changed. This is an internal method and should not be used by plugins.
+ *
+ * @returns An object with an invoke and reset function.
+ */
+export declare function provideConfigurationValuesChanged(): {
+    invoke: () => void;
+    reset: () => void;
+};
+/**
+ * Registered a function to be called when the block configuration values have
+ * changed.
+ *
+ * @param callback The function to be called when the configuration values have changed.
+ */
+export declare function onConfigurationValuesChanged(callback: () => void): void;
+/**
+ * A type that returns the keys of a child property.
+ */
+declare type ChildKeys<T extends Record<string, unknown>, PropertyName extends string> = keyof NonNullable<T[PropertyName]> & string;
+/**
+ * A valid properties box that uses the specified name for the content bag.
+ */
+declare type ValidPropertiesBox<PropertyName extends string> = {
+    validProperties?: string[] | null;
+} & {
+    [P in PropertyName]?: Record<string, unknown> | null;
+};
+/**
+ * Sets the a value for a custom settings box. This will set the value and then
+ * add the property name to the list of valid properties.
+ *
+ * @param box The box whose custom setting value will be set.
+ * @param propertyName The name of the custom setting property to set.
+ * @param value The new value of the custom setting.
+ */
+export declare function setCustomSettingsBoxValue<T extends ValidPropertiesBox<"settings">, S extends NonNullable<T["settings"]>, K extends ChildKeys<T, "settings">>(box: T, propertyName: K, value: S[K]): void;
+/**
+ * Sets the a value for a property box. This will set the value and then
+ * add the property name to the list of valid properties.
+ *
+ * @param box The box whose property value will be set.
+ * @param propertyName The name of the property on the bag to set.
+ * @param value The new value of the property.
+ */
+export declare function setPropertiesBoxValue<T extends ValidPropertiesBox<"bag">, S extends NonNullable<T["bag"]>, K extends ChildKeys<T, "bag">>(box: T, propertyName: K, value: S[K]): void;
+/**
+ * Dispatches a block event to the document.
+ *
+ * @param eventName The name of the event to be dispatched.
+ * @param eventData The custom data to be attached to the event.
+ *
+ * @returns true if preventDefault() was called on the event, otherwise false.
+ */
+export declare function dispatchBlockEvent(eventName: string, blockGuid: Guid, eventData?: unknown): boolean;
+/**
+ * Tests if the given event is a custom block event. This does not ensure
+ * that the event data is the correct type, only the event itself.
+ *
+ * @param event The event to be tested.
+ *
+ * @returns true if the event is a block event.
+ */
+export declare function isBlockEvent<TData = undefined>(event: Event): event is CustomEvent<BlockEvent<TData>>;
+/**
+ * Use a security grant token value provided by the server. This returns a reference
+ * to the actual value and will automatically handle renewing the token and updating
+ * the value. This function is meant to be used by blocks. Controls should use the
+ * useSecurityGrant() function instead.
+ *
+ * @param token The token provided by the server.
+ *
+ * @returns A reference to the security grant that will be updated automatically when it has been renewed.
+ */
+export declare function getSecurityGrant(token: string | null | undefined): SecurityGrant;
+/**
+ * Provides the security grant to child components to use in their API calls.
+ *
+ * @param grant The grant ot provide to child components.
+ */
+export declare function provideSecurityGrant(grant: SecurityGrant): void;
+/**
+ * Uses a previously provided security grant token by a parent component.
+ * This function is meant to be used by controls that need to obtain a security
+ * grant from a parent component.
+ *
+ * @returns A string reference that contains the security grant token.
+ */
+export declare function useSecurityGrantToken(): Ref<string | null>;
+/** An emit object that conforms to having a propertyChanged event. */
+export declare type PropertyChangedEmitFn<E extends "propertyChanged"> = E extends Array<infer EE> ? (event: EE, ...args: any[]) => void : (event: E, ...args: any[]) => void;
+/**
+ * Watches for changes to the given Ref objects and emits a special event to
+ * indicate that a given property has changed.
+ *
+ * @param propertyRefs The ExtendedRef objects to watch for changes.
+ * @param emit The emit function for the component.
+ */
+export declare function watchPropertyChanges<E extends "propertyChanged">(propertyRefs: ExtendedRef<unknown>[], emit: PropertyChangedEmitFn<E>): void;
+/**
+ * Requests an updated attribute list from the server based on the
+ * current UI selections made.
+ *
+ * @param bag The entity bag that will be used to determine current property values
+ * and then updated with the new attributes and values.
+ * @param validProperties The properties that are considered valid on the bag when
+ * the server will read the bag.
+ * @param invokeBlockAction The function to use when calling the block action.
+ */
+export declare function refreshDetailAttributes<TEntityBag>(bag: Ref<TEntityBag>, validProperties: string[], invokeBlockAction: InvokeBlockActionFunc): Promise<void>;
+/**
+ * Provides the block unique identifier to all child components.
+ * This is an internal method and should not be used by plugins.
+ *
+ * @param blockGuid The unique identifier of the block.
+ */
+export declare function provideBlockGuid(blockGuid: string): void;
+/**
+ * Gets the unique identifier of the current block in this component chain.
+ *
+ * @returns The unique identifier of the block.
+ */
+export declare function useBlockGuid(): Guid | undefined;
+/**
+ * Provides the person preferences provider that will be used by components
+ * to access the person preferences associated with their block.
+ *
+ * @private This is an internal method and should not be used by plugins.
+ *
+ * @param blockGuid The unique identifier of the block.
+ */
+export declare function providePersonPreferences(provider: IBlockPersonPreferencesProvider): void;
+/**
+ * Gets the person preference provider that can be used to access block
+ * preferences as well as other preferences.
+ *
+ * @returns An object that implements {@link IBlockPersonPreferencesProvider}.
+ */
+export declare function usePersonPreferences(): IBlockPersonPreferencesProvider;
+export {};

package/types/Utility/booleanUtils.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Transform the value into true, false, or null
+ * @param val
+ */
+export declare function asBooleanOrNull(val: unknown): boolean | null;
+/**
+ * Transform the value into true or false
+ * @param val
+ */
+export declare function asBoolean(val: unknown): boolean;
+/** Transform the value into the strings "Yes", "No", or null */
+export declare function asYesNoOrNull(val: unknown): "Yes" | "No" | null;
+/** Transform the value into the strings "True", "False", or null */
+export declare function asTrueFalseOrNull(val: unknown): "True" | "False" | null;
+/** Transform the value into the strings "True" if truthy or "False" if falsey */
+export declare function asTrueOrFalseString(val: unknown): "True" | "False";

package/types/Utility/bus.d.ts

@@ -0,0 +1,23 @@
+import { RockDateTime } from "./rockDateTime";
+/**
+ * The bus allows page components to send and receive arbitrary data from other page components.
+ */
+declare type LogItem = {
+    date: RockDateTime;
+    message: string;
+};
+/**
+* Send the payload to subscribers listening for the event name
+*/
+declare function publish<T>(eventName: string, payload: T): void;
+/**
+* Whenever an event is received of eventName, the callback is executed with the message
+* payload as a parameter.
+*/
+declare function subscribe<T>(eventName: string, callback: (payload: T) => void): void;
+declare const _default: {
+    publish: typeof publish;
+    subscribe: typeof subscribe;
+    log: LogItem[];
+};
+export default _default;

package/types/Utility/cache.d.ts

@@ -0,0 +1,32 @@
+import { RockDateTime } from "./rockDateTime";
+/**
+* Stores the value using the given key. The cache will expire at the expiration or in
+* 1 minute if none is provided
+* @param key
+* @param value
+* @param expiration
+*/
+declare function set<T>(key: string, value: T, expirationDT?: RockDateTime | null): void;
+/**
+ * Gets a stored cache value if there is one that has not yet expired.
+ * @param key
+ */
+declare function get<T>(key: string): T | null;
+/**
+ * Since Promises can't be cached, we need to store them in memory until we get the result back. This wraps
+ * a function in another function that returns a promise and...
+ * - If there's a cached result, return it
+ * - Otherwise if there's a cached Promise, return it
+ * - Otherwise call the given function and cache it's promise and return it. Once the the Promise resolves, cache its result
+ *
+ * @param key Key for identifying the cached values
+ * @param fn Function that returns a Promise that we want to cache the value of
+ *
+ */
+declare function cachePromiseFactory<T>(key: string, fn: () => Promise<T>, expiration?: RockDateTime | null): () => Promise<T>;
+declare const _default: {
+    set: typeof set;
+    get: typeof get;
+    cachePromiseFactory: typeof cachePromiseFactory;
+};
+export default _default;

package/types/Utility/cancellation.d.ts

@@ -0,0 +1,58 @@
+/**
+ * A cancellation token can be used to instruct some operation to run but abort
+ * if a certain condition is met.
+ */
+export interface ICancellationToken {
+    /**
+     * A flag signalling is cancellation has been requested.
+     */
+    readonly isCancellationRequested: boolean;
+    /**
+     * Registers a listener for when cancellation has been requested. This event
+     * only ever fires `once` as cancellation can only happen once. Listeners
+     * that are registered after cancellation will be called (next event loop run),
+     * but also only once.
+     *
+     * @param listener The function to be called when the token has been cancelled.
+     */
+    onCancellationRequested(listener: () => void): void;
+}
+/**
+ * Determines if something is a cancellation token.
+ *
+ * @param thing The thing to be checked to see if it is a cancellation token.
+ *
+ * @returns true if the @{link thing} is a cancellation token, otherwise false.
+ */
+export declare function isCancellationToken(thing: unknown): thing is ICancellationToken;
+/**
+ * A cancellation token that will never be in a cancelled state.
+ */
+export declare const CancellationTokenNone: Readonly<ICancellationToken>;
+/**
+ * A cancellation token that is already in a cancelled state.
+ */
+export declare const CancellationTokenCancelled: Readonly<ICancellationToken>;
+/**
+ * Creates a source instance that can be used to trigger a cancellation
+ * token into the cancelled state.
+ */
+export declare class CancellationTokenSource {
+    /** The token that can be passed to functions. */
+    private internalToken?;
+    /**
+     * Creates a new instance of {@link CancellationTokenSource}.
+     *
+     * @param parent The parent cancellation token that will also cancel this source.
+     */
+    constructor(parent?: ICancellationToken);
+    /**
+     * The cancellation token that can be used to determine when the task
+     * should be cancelled.
+     */
+    get token(): ICancellationToken;
+    /**
+     * Moves the token into a cancelled state.
+     */
+    cancel(): void;
+}

package/types/Utility/component.d.ts

@@ -0,0 +1,199 @@
+import { AsyncComponentLoader, Component, ComponentPublicInstance, ExtractPropTypes, PropType, Ref, VNode, WatchOptions } from "vue";
+import { ControlLazyMode } from "@Obsidian/Enums/Controls/controlLazyMode";
+import { PickerDisplayStyle } from "@Obsidian/Enums/Controls/pickerDisplayStyle";
+import { ExtendedRef, ExtendedRefContext } from "@Obsidian/Types/Utility/component";
+import type { RulesPropType } from "@Obsidian/Types/validationRules";
+declare type Prop = {
+    [key: string]: unknown;
+};
+declare type PropKey<T extends Prop> = Extract<keyof T, string>;
+declare type EmitFn<E extends `update:${string}`> = E extends Array<infer EE> ? (event: EE, ...args: any[]) => void : (event: E, ...args: any[]) => void;
+/**
+ * Utility function for when you are using a component that takes a v-model
+ * and uses that model as a v-model in that component's template. It creates
+ * a new ref that keeps itself up-to-date with the given model and fires an
+ * 'update:MODELNAME' event when it gets changed.
+ *
+ * Ensure the related `props` and `emits` are specified to ensure there are
+ * no type issues.
+ */
+export declare function useVModelPassthrough<T extends Prop, K extends PropKey<T>, E extends `update:${K}`>(props: T, modelName: K, emit: EmitFn<E>, options?: WatchOptions): Ref<T[K]>;
+/**
+ * Utility function for when you are using a component that takes a v-model
+ * and uses that model as a v-model in that component's template. It creates
+ * a new ref that keeps itself up-to-date with the given model and fires an
+ * 'update:MODELNAME' event when it gets changed. It also gives a means of watching
+ * the model prop for any changes (verifies that the prop change is different than
+ * the current value first)
+ *
+ * Ensure the related `props` and `emits` are specified to ensure there are
+ * no type issues.
+ */
+export declare function useVModelPassthroughWithPropUpdateCheck<T extends Prop, K extends PropKey<T>, E extends `update:${K}`>(props: T, modelName: K, emit: EmitFn<E>, options?: WatchOptions): [Ref<T[K]>, (fn: () => unknown) => void];
+/**
+ * Updates the Ref value, but only if the new value is actually different than
+ * the current value. A deep comparison is performed.
+ *
+ * @param target The target Ref object to be updated.
+ * @param value The new value to be assigned to the target.
+ *
+ * @returns True if the target was updated, otherwise false.
+ */
+export declare function updateRefValue<T, TV extends T>(target: Ref<T>, value: TV): boolean;
+/**
+ * Defines a component that will be loaded asynchronously. This contains logic
+ * to properly work with the RockSuspense control.
+ *
+ * @param source The function to call to load the component.
+ *
+ * @returns The component that was loaded.
+ */
+export declare function defineAsyncComponent<T extends Component = {
+    new (): ComponentPublicInstance;
+}>(source: AsyncComponentLoader<T>): T;
+declare type StandardRockFormFieldProps = {
+    label: {
+        type: PropType<string>;
+        default: "";
+    };
+    help: {
+        type: PropType<string>;
+        default: "";
+    };
+    rules: RulesPropType;
+    formGroupClasses: {
+        type: PropType<string>;
+        default: "";
+    };
+    validationTitle: {
+        type: PropType<string>;
+        default: "";
+    };
+    isRequiredIndicatorHidden: {
+        type: PropType<boolean>;
+        default: false;
+    };
+};
+/** The standard component props that should be included when using RockFormField. */
+export declare const standardRockFormFieldProps: StandardRockFormFieldProps;
+/**
+ * Configures the basic properties that should be passed to the RockFormField
+ * component. The value returned by this function should be used with v-bind on
+ * the RockFormField in order to pass all the defined prop values to it.
+ *
+ * @param props The props of the component that will be using the RockFormField.
+ *
+ * @returns An object of prop values that can be used with v-bind.
+ */
+export declare function useStandardRockFormFieldProps(props: ExtractPropTypes<StandardRockFormFieldProps>): ExtractPropTypes<StandardRockFormFieldProps>;
+declare type StandardAsyncPickerProps = StandardRockFormFieldProps & {
+    /** Enhance the picker for dealing with long lists by providing a search mechanism. */
+    enhanceForLongLists: {
+        type: PropType<boolean>;
+        default: false;
+    };
+    /** The method the picker should use to load data. */
+    lazyMode: {
+        type: PropType<ControlLazyMode>;
+        default: "onDemand";
+    };
+    /** True if the picker should allow multiple items to be selected. */
+    multiple: {
+        type: PropType<boolean>;
+        default: false;
+    };
+    /** True if the picker should allow empty selections. */
+    showBlankItem: {
+        type: PropType<boolean>;
+        default: false;
+    };
+    /** The optional value to show when `showBlankItem` is `true`. */
+    blankValue: {
+        type: PropType<string>;
+        default: "";
+    };
+    /** The visual style to use when displaying the picker. */
+    displayStyle: {
+        type: PropType<PickerDisplayStyle>;
+        default: "auto";
+    };
+    /** The number of columns to use when displaying the items in a list. */
+    columnCount: {
+        type: PropType<number>;
+        default: 0;
+    };
+};
+/** The standard component props that should be included when using BaseAsyncPicker. */
+export declare const standardAsyncPickerProps: StandardAsyncPickerProps;
+/**
+ * Configures the basic properties that should be passed to the BaseAsyncPicker
+ * component. The value returned by this function should be used with v-bind on
+ * the BaseAsyncPicker in order to pass all the defined prop values to it.
+ *
+ * @param props The props of the component that will be using the BaseAsyncPicker.
+ *
+ * @returns An object of prop values that can be used with v-bind.
+ */
+export declare function useStandardAsyncPickerProps(props: ExtractPropTypes<StandardAsyncPickerProps>): ExtractPropTypes<StandardAsyncPickerProps>;
+/**
+ * Creates a Ref that contains extended data to better identify this ref
+ * when you have multiple refs to work with.
+ *
+ * @param value The initial value of the Ref.
+ * @param extendedData The additional context data to put on the Ref.
+ *
+ * @returns An ExtendedRef object that can be used like a regular Ref object.
+ */
+export declare function extendedRef<T>(value: T, context: ExtendedRefContext): ExtendedRef<T>;
+/**
+ * Creates an extended Ref with the specified property name in the context.
+ *
+ * @param value The initial value of the Ref.
+ * @param propertyName The property name to use for the context.
+ *
+ * @returns An ExtendedRef object that can be used like a regular Ref object.
+ */
+export declare function propertyRef<T>(value: T, propertyName: string): ExtendedRef<T>;
+/**
+ * Retrieves a single prop value from a VNode object. If the prop is explicitely
+ * specified in the DOM then it will be returned. Otherwise the component's
+ * prop default values are checked. If there is a default value it will be
+ * returned.
+ *
+ * @param node The node whose property value is being requested.
+ * @param propName The name of the property whose value is being requested.
+ *
+ * @returns The value of the property or `undefined` if it was not set.
+ */
+export declare function getVNodeProp<T>(node: VNode, propName: string): T | undefined;
+/**
+ * Retrieves all prop values from a VNode object. First all default values
+ * from the component are retrieved. Then any specified on the DOM will be used
+ * to override those default values.
+ *
+ * @param node The node whose property values are being requested.
+ *
+ * @returns An object that contains all props and values for the node.
+ */
+export declare function getVNodeProps(node: VNode): Record<string, unknown>;
+/**
+ * Renders the node into an off-screen div and then extracts the text content
+ * by way of the innerText property of the div.
+ *
+ * @param node The node or component to be rendered.
+ * @param props The properties to be passed to the component when it is mounted.
+ *
+ * @returns The text content of the node after it has rendered.
+ */
+export declare function extractText(node: VNode | Component, props?: Record<string, unknown>): string;
+/**
+ * Renders the node into an off-screen div and then extracts the HTML content
+ * by way of the innerHTML property of the div.
+ *
+ * @param node The node or component to be rendered.
+ * @param props The properties to be passed to the component when it is mounted.
+ *
+ * @returns The HTML content of the node after it has rendered.
+ */
+export declare function extractHtml(node: VNode | Component, props?: Record<string, unknown>): string;
+export {};

package/types/Utility/dateKey.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Gets the year value from the date key.
+ * Ex: 20210228 => 2021
+ * @param dateKey
+ */
+export declare function getYear(dateKey: string | null): number;
+/**
+ * Gets the month value from the date key.
+ * Ex: 20210228 => 2
+ * @param dateKey
+ */
+export declare function getMonth(dateKey: string | null): number;
+/**
+ * Gets the day value from the date key.
+ * Ex: 20210228 => 28
+ * @param dateKey
+ */
+export declare function getDay(dateKey: string | null): number;
+/**
+ * Gets the datekey constructed from the parts.
+ * Ex: (2021, 2, 28) => '20210228'
+ * @param year
+ * @param month
+ * @param day
+ */
+export declare function toDateKey(year: number | null, month: number | null, day: number | null): string;
+/**
+ * Gets the datekey constructed from the parts.
+ * Ex: (2, 28) => '0228'
+ * @param month
+ * @param day
+ */
+export declare function toNoYearDateKey(month: number | null, day: number | null): string;
+declare const _default: {
+    getYear: typeof getYear;
+    getMonth: typeof getMonth;
+    getDay: typeof getDay;
+    toDateKey: typeof toDateKey;
+    toNoYearDateKey: typeof toNoYearDateKey;
+};
+export default _default;

package/types/Utility/dialogs.d.ts

@@ -0,0 +1,38 @@
+import { Guid } from "@Obsidian/Types";
+/**
+ * Shows an alert message that requires the user to acknowledge.
+ *
+ * @param message The message text to be displayed.
+ *
+ * @returns A promise that indicates when the dialog has been dismissed.
+ */
+export declare function alert(message: string): Promise<void>;
+/**
+ * Shows a confirmation dialog that consists of OK and Cancel buttons. The
+ * user will be required to click one of these two buttons.
+ *
+ * @param message The message to be displayed inside the dialog.
+ *
+ * @returns A promise that indicates when the dialog has been dismissed. The
+ * value will be true if the OK button was clicked or false otherwise.
+ */
+export declare function confirm(message: string): Promise<boolean>;
+/**
+ * Shows a delete confirmation dialog that consists of OK and Cancel buttons.
+ * The user will be required to click one of these two buttons. The message
+ * is standardized.
+ *
+ * @param nameText The name of type that will be deleted.
+ *
+ * @returns A promise that indicates when the dialog has been dismissed. The
+ * value will be true if the OK button was clicked or false otherwise.
+ */
+export declare function confirmDelete(typeName: string, additionalMessage?: string): Promise<boolean>;
+/**
+ * Shows the security dialog for the given entity.
+ *
+ * @param entityTypeIdKey The identifier of the entity's type.
+ * @param entityIdKey The identifier of the entity to secure.
+ * @param entityTitle The title of the entity. This is used to construct the modal title.
+ */
+export declare function showSecurity(entityTypeIdKey: Guid | string | number, entityIdKey: Guid | string | number, entityTitle?: string): void;

package/types/Utility/email.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Is the value a valid email address?
+ * @param val
+ */
+export declare function isEmail(val: unknown): boolean;

package/types/Utility/enumUtils.d.ts

@@ -0,0 +1,9 @@
+import { ListItemBag } from "@Obsidian/ViewModels/Utility/listItemBag";
+/**
+ * A function to convert the enums to array of ListItemBag in the frontend.
+ *
+ * @param description The enum to be converted to an array of listItemBag as a dictionary of value to enum description
+ *
+ * @returns An array of ListItemBag.
+ */
+export declare function enumToListItemBag(description: Record<number, string>): ListItemBag[];

package/types/Utility/fieldTypes.d.ts

@@ -0,0 +1,20 @@
+import { Guid } from "@Obsidian/Types";
+import { IFieldType } from "@Obsidian/Types/fieldType";
+/** Determines how the field type component is being used so it can adapt to different */
+export declare type DataEntryMode = "defaultValue" | undefined;
+/**
+ * Register a new field type in the system. This must be called for all field
+ * types a plugin registers.
+ *
+ * @param fieldTypeGuid The unique identifier of the field type.
+ * @param fieldType The class instance that will handle the field type.
+ */
+export declare function registerFieldType(fieldTypeGuid: Guid, fieldType: IFieldType): void;
+/**
+ * Get the field type handler for a given unique identifier.
+ *
+ * @param fieldTypeGuid The unique identifier of the field type.
+ *
+ * @returns The field type instance or null if not found.
+ */
+export declare function getFieldType(fieldTypeGuid: Guid): IFieldType | null;