grassroot
Install

DocsAPI referenceHeadlessasync-validated-input

async-validated-input headless API

The core connector and vanilla mount are always visible. Use the framework choice to inspect native composition, props, outputs, context and hooks for the selected adapter.

Machine API

@grassroot/ui-headless-core/async-validated-input

Core connector and vanilla API

23 exports
View source packages/ui-headless/core/src/async-validated-input/index.ts

asyncValidatedInputAnatomy

value
DeclarationView source
asyncValidatedInputAnatomyts
export declare const asyncValidatedInputAnatomy: {
  readonly scope: "async-validated-input";
  readonly parts: readonly ["root", "input", "submit", "message"];
};
Name
Kind
Type
Requirement
parts
property
readonly ["root", "input", "submit", "message"]
required
scope
property
"async-validated-input"
required
Name
parts
Kind
property
Type
readonly ["root", "input", "submit", "message"]
Requirement
required
Name
scope
Kind
property
Type
"async-validated-input"
Requirement
required

AsyncValidatedInputApi

interface
DeclarationView source
AsyncValidatedInputApits
interface AsyncValidatedInputApi {
  rootProps(): PartProps;
  inputProps(): PartProps;
  submitProps(): PartProps;
  messageProps(): PartProps;
  syncNativeState(): void;
  validateSucceeded(): void;
  validateFailed(): void;
  reset(): void;
  readonly value: string;
  readonly pending: boolean;
  readonly status: AsyncValidatedInputContext["status"];
  readonly snapshot: AsyncValidatedInputSnapshot;
}
Name
Kind
Type
Requirement
inputProps
method
() => PartProps
required
messageProps
method
() => PartProps
required
pending
property
boolean
required
reset
method
() => void
required
rootProps
method
() => PartProps
required
snapshot
property
AsyncValidatedInputSnapshot
required
status
property
AsyncValidatedInputContext["status"]
required
submitProps
method
() => PartProps
required
syncNativeState
method
() => void
required
validateFailed
method
() => void
required
validateSucceeded
method
() => void
required
value
property
string
required
Name
inputProps
Kind
method
Type
() => PartProps
Requirement
required
Name
messageProps
Kind
method
Type
() => PartProps
Requirement
required
Name
pending
Kind
property
Type
boolean
Requirement
required
Name
reset
Kind
method
Type
() => void
Requirement
required
Name
rootProps
Kind
method
Type
() => PartProps
Requirement
required
Name
snapshot
Kind
property
Type
AsyncValidatedInputSnapshot
Requirement
required
Name
status
Kind
property
Type
AsyncValidatedInputContext["status"]
Requirement
required
Name
submitProps
Kind
method
Type
() => PartProps
Requirement
required
Name
syncNativeState
Kind
method
Type
() => void
Requirement
required
Name
validateFailed
Kind
method
Type
() => void
Requirement
required
Name
validateSucceeded
Kind
method
Type
() => void
Requirement
required
Name
value
Kind
property
Type
string
Requirement
required

AsyncValidatedInputCommand

type
DeclarationView source
AsyncValidatedInputCommandts
type AsyncValidatedInputCommand = (CommandObject & {
  readonly type: "VALIDATE_REQUEST";
  readonly value: string;
  readonly reason: AsyncValidatedInputReason;
}) | (CommandObject & {
  readonly type: "VALUE_CHANGE_REQUEST";
  readonly value: string;
  readonly reason: AsyncValidatedInputReason;
});

AsyncValidatedInputConnectOptions

interface
DeclarationView source
AsyncValidatedInputConnectOptionsts
interface AsyncValidatedInputConnectOptions {
  readonly ariaLabel?: string;
  readonly message?: string;
  readonly messages?: Partial<AsyncValidatedInputMessages>;
  readonly onValueChange?: (detail: AsyncValidatedInputValueChangeDetail) => void;
  readonly onValidate?: (detail: AsyncValidatedInputValidateDetail) => void;
}
Name
Kind
Type
Requirement
ariaLabel
property
string
optional
message
property
string
optional
messages
property
Partial<AsyncValidatedInputMessages>
optional
onValidate
property
(detail: AsyncValidatedInputValidateDetail) => void
optional
onValueChange
property
(detail: AsyncValidatedInputValueChangeDetail) => void
optional
Name
ariaLabel
Kind
property
Type
string
Requirement
optional
Name
message
Kind
property
Type
string
Requirement
optional
Name
messages
Kind
property
Type
Partial<AsyncValidatedInputMessages>
Requirement
optional
Name
onValidate
Kind
property
Type
(detail: AsyncValidatedInputValidateDetail) => void
Requirement
optional
Name
onValueChange
Kind
property
Type
(detail: AsyncValidatedInputValueChangeDetail) => void
Requirement
optional

AsyncValidatedInputContext

type
DeclarationView source
AsyncValidatedInputContextts
type AsyncValidatedInputContext = {
  readonly value: string;
  readonly pending: boolean;
  readonly status: AsyncValidatedInputStatus;
  readonly mode: BindingMode;
};
Name
Kind
Type
Requirement
mode
property
BindingMode
required
pending
property
boolean
required
status
property
AsyncValidatedInputStatus
required
value
property
string
required
Name
mode
Kind
property
Type
BindingMode
Requirement
required
Name
pending
Kind
property
Type
boolean
Requirement
required
Name
status
Kind
property
Type
AsyncValidatedInputStatus
Requirement
required
Name
value
Kind
property
Type
string
Requirement
required

AsyncValidatedInputEvent

type
DeclarationView source
AsyncValidatedInputEventts
type AsyncValidatedInputEvent = {
  readonly type: "SET_VALUE";
  readonly value: string;
  readonly reason: AsyncValidatedInputReason;
} | {
  readonly type: "VALIDATE";
  readonly reason: AsyncValidatedInputReason;
} | {
  readonly type: "VALIDATE_SUCCEEDED";
} | {
  readonly type: "VALIDATE_FAILED";
} | {
  readonly type: "RESET";
};

AsyncValidatedInputInput

type
DeclarationView source
AsyncValidatedInputInputts
type AsyncValidatedInputInput = {
  readonly value?: string;
  readonly defaultValue?: string;
  readonly pending?: boolean;
  readonly status?: AsyncValidatedInputStatus;
};
Name
Kind
Type
Requirement
defaultValue
property
string
optional
pending
property
boolean
optional
status
property
AsyncValidatedInputStatus
optional
value
property
string
optional
Name
defaultValue
Kind
property
Type
string
Requirement
optional
Name
pending
Kind
property
Type
boolean
Requirement
optional
Name
status
Kind
property
Type
AsyncValidatedInputStatus
Requirement
optional
Name
value
Kind
property
Type
string
Requirement
optional

asyncValidatedInputMachine

value
DeclarationView source
asyncValidatedInputMachinets
export declare const asyncValidatedInputMachine: Machine<AsyncValidatedInputInput, "ready", AsyncValidatedInputContext, AsyncValidatedInputEvent, AsyncValidatedInputCommand>;

asyncValidatedInputMessages

value
DeclarationView source
asyncValidatedInputMessagests
export declare const asyncValidatedInputMessages: AsyncValidatedInputMessages;

AsyncValidatedInputMessages

interface
DeclarationView source
AsyncValidatedInputMessagests
interface AsyncValidatedInputMessages {
  readonly inputLabel: () => string;
}
Name
Kind
Type
Requirement
inputLabel
property
() => string
required
Name
inputLabel
Kind
property
Type
() => string
Requirement
required

AsyncValidatedInputMount

interface
DeclarationView source
AsyncValidatedInputMountts
interface AsyncValidatedInputMount {
  readonly service: AsyncValidatedInputService;
  readonly connector: AsyncValidatedInputApi;
  readonly root: HTMLElement;
  readonly input: HTMLInputElement;
  readonly submit: HTMLButtonElement;
  readonly message: HTMLSpanElement;
  destroy(): void;
}
Name
Kind
Type
Requirement
connector
property
AsyncValidatedInputApi
required
destroy
method
() => void
required
input
property
HTMLInputElement
required
message
property
HTMLSpanElement
required
root
property
HTMLElement
required
service
property
AsyncValidatedInputService
required
submit
property
HTMLButtonElement
required
Name
connector
Kind
property
Type
AsyncValidatedInputApi
Requirement
required
Name
destroy
Kind
method
Type
() => void
Requirement
required
Name
input
Kind
property
Type
HTMLInputElement
Requirement
required
Name
message
Kind
property
Type
HTMLSpanElement
Requirement
required
Name
root
Kind
property
Type
HTMLElement
Requirement
required
Name
service
Kind
property
Type
AsyncValidatedInputService
Requirement
required
Name
submit
Kind
property
Type
HTMLButtonElement
Requirement
required

AsyncValidatedInputPart

type
DeclarationView source
AsyncValidatedInputPartts
type AsyncValidatedInputPart = (typeof asyncValidatedInputAnatomy.parts)[number];

AsyncValidatedInputReason

type
DeclarationView source
AsyncValidatedInputReasonts
type AsyncValidatedInputReason = "pointer" | "keyboard" | "programmatic";

asyncValidatedInputSelectors

value
DeclarationView source
asyncValidatedInputSelectorsts
export declare const asyncValidatedInputSelectors: {
  value: (snapshot: AsyncValidatedInputSnapshot) => string;
  pending: (snapshot: AsyncValidatedInputSnapshot) => boolean;
};
Name
Kind
Type
Requirement
pending
property
(snapshot: AsyncValidatedInputSnapshot) => boolean
required
value
property
(snapshot: AsyncValidatedInputSnapshot) => string
required
Name
pending
Kind
property
Type
(snapshot: AsyncValidatedInputSnapshot) => boolean
Requirement
required
Name
value
Kind
property
Type
(snapshot: AsyncValidatedInputSnapshot) => string
Requirement
required

AsyncValidatedInputService

type
DeclarationView source
AsyncValidatedInputServicets
type AsyncValidatedInputService = Service<AsyncValidatedInputInput, "ready", AsyncValidatedInputContext, AsyncValidatedInputEvent, AsyncValidatedInputCommand>;

AsyncValidatedInputSnapshot

type
DeclarationView source
AsyncValidatedInputSnapshotts
type AsyncValidatedInputSnapshot = Snapshot<"ready", AsyncValidatedInputContext>;

AsyncValidatedInputStatus

type
DeclarationView source
AsyncValidatedInputStatusts
type AsyncValidatedInputStatus = "idle" | "validating" | "valid" | "error";

AsyncValidatedInputValidateDetail

interface
DeclarationView source
AsyncValidatedInputValidateDetailts
interface AsyncValidatedInputValidateDetail {
  readonly value: string;
  readonly reason: "pointer" | "keyboard" | "programmatic";
}
Name
Kind
Type
Requirement
reason
property
"pointer" | "keyboard" | "programmatic"
required
value
property
string
required
Name
reason
Kind
property
Type
"pointer" | "keyboard" | "programmatic"
Requirement
required
Name
value
Kind
property
Type
string
Requirement
required

AsyncValidatedInputValueChangeDetail

interface
DeclarationView source
AsyncValidatedInputValueChangeDetailts
interface AsyncValidatedInputValueChangeDetail {
  readonly value: string;
  readonly reason: "pointer" | "keyboard" | "programmatic";
}
Name
Kind
Type
Requirement
reason
property
"pointer" | "keyboard" | "programmatic"
required
value
property
string
required
Name
reason
Kind
property
Type
"pointer" | "keyboard" | "programmatic"
Requirement
required
Name
value
Kind
property
Type
string
Requirement
required

connectAsyncValidatedInput

function
DeclarationView source
connectAsyncValidatedInputts
declare function connectAsyncValidatedInput(service: AsyncValidatedInputService, scope: PartScope, options?: AsyncValidatedInputConnectOptions): AsyncValidatedInputApi;
Name
Kind
Type
Requirement
service
parameter
AsyncValidatedInputService
required
scope
parameter
PartScope
required
options
parameter
AsyncValidatedInputConnectOptions
optional
return
return value
AsyncValidatedInputApi
n/a
Name
service
Kind
parameter
Type
AsyncValidatedInputService
Requirement
required
Name
scope
Kind
parameter
Type
PartScope
Requirement
required
Name
options
Kind
parameter
Type
AsyncValidatedInputConnectOptions
Requirement
optional
Name
return
Kind
return value
Type
AsyncValidatedInputApi
Requirement
n/a

mountAsyncValidatedInput

function
DeclarationView source
mountAsyncValidatedInputts
declare function mountAsyncValidatedInput(container: HTMLElement, options?: MountAsyncValidatedInputOptions): AsyncValidatedInputMount;
Name
Kind
Type
Requirement
container
parameter
HTMLElement
required
options
parameter
MountAsyncValidatedInputOptions
optional
return
return value
AsyncValidatedInputMount
n/a
Name
container
Kind
parameter
Type
HTMLElement
Requirement
required
Name
options
Kind
parameter
Type
MountAsyncValidatedInputOptions
Requirement
optional
Name
return
Kind
return value
Type
AsyncValidatedInputMount
Requirement
n/a

MountAsyncValidatedInputOptions

interface
DeclarationView source
MountAsyncValidatedInputOptionsts
interface MountAsyncValidatedInputOptions extends AsyncValidatedInputInput, AsyncValidatedInputConnectOptions {}

runAsyncValidatedInputCommand

function
DeclarationView source
runAsyncValidatedInputCommandts
declare function runAsyncValidatedInputCommand(command: AsyncValidatedInputCommand, options?: Pick<AsyncValidatedInputConnectOptions, "onValueChange" | "onValidate">): void;
Name
Kind
Type
Requirement
command
parameter
AsyncValidatedInputCommand
required
options
parameter
Pick<AsyncValidatedInputConnectOptions, "onValueChange" | "onValidate">
optional
return
return value
void
n/a
Name
command
Kind
parameter
Type
AsyncValidatedInputCommand
Requirement
required
Name
options
Kind
parameter
Type
Pick<AsyncValidatedInputConnectOptions, "onValueChange" | "onValidate">
Requirement
optional
Name
return
Kind
return value
Type
void
Requirement
n/a

Framework adapters

Each panel keeps its adapter's public vocabulary. React compound exports, Vue composables, standalone Angular declarations, Svelte components, and Solid hooks stay native to their framework.

React example follows below.

React imports

@grassroot/ui-headless-react/async-validated-inputts
import { AsyncValidatedInputMessage, AsyncValidatedInputRoot, AsyncValidatedInputRootProvider, AsyncValidatedInputSubmit, Message, Root, RootProvider, Submit } from "@grassroot/ui-headless-react/async-validated-input";

Vue imports

@grassroot/ui-headless-vue/async-validated-inputts
<script setup lang="ts">
import { AsyncValidatedInputMessage, AsyncValidatedInputRoot, AsyncValidatedInputRootProvider, AsyncValidatedInputSubmit, Message, Root, RootProvider, Submit } from "@grassroot/ui-headless-vue/async-validated-input";
</script>

Angular imports

@grassroot/ui-headless-angular/async-validated-inputts
import { GrAsyncValidatedInputMessage, GrAsyncValidatedInputRoot, GrAsyncValidatedInputRootProvider, GrAsyncValidatedInputSubmit, Message, Root, RootProvider, Submit } from "@grassroot/ui-headless-angular/async-validated-input";

Svelte imports

@grassroot/ui-headless-svelte/async-validated-inputts
<script lang="ts">
  import { AsyncValidatedInputMessage, AsyncValidatedInputRoot, AsyncValidatedInputRootProvider, AsyncValidatedInputSubmit, Message, Root, RootProvider, Submit } from "@grassroot/ui-headless-svelte/async-validated-input";
</script>

Solid imports

@grassroot/ui-headless-solid/async-validated-inputts
import { AsyncValidatedInputMessage, AsyncValidatedInputRoot, AsyncValidatedInputRootProvider, AsyncValidatedInputSubmit, Message, Root, RootProvider, Submit } from "@grassroot/ui-headless-solid/async-validated-input";

@grassroot/ui-headless-react/async-validated-input

React adapter

18 exports
View source packages/ui-headless/react/src/async-validated-input/index.ts

AsyncValidatedInputInput

value
DeclarationView source
AsyncValidatedInputInputts
export declare const AsyncValidatedInputInput: import("react").ForwardRefExoticComponent<AsyncValidatedInputInputProps & import("react").RefAttributes<HTMLInputElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

AsyncValidatedInputInputProps

interface
DeclarationView source
AsyncValidatedInputInputPropsts
interface AsyncValidatedInputInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "value" | "defaultValue" | "onChange" | "onInput"> {}

AsyncValidatedInputMessage

value
DeclarationView source
AsyncValidatedInputMessagets
export declare const AsyncValidatedInputMessage: import("react").ForwardRefExoticComponent<AsyncValidatedInputMessageProps & import("react").RefAttributes<HTMLSpanElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

AsyncValidatedInputMessageProps

interface
DeclarationView source
AsyncValidatedInputMessagePropsts
interface AsyncValidatedInputMessageProps extends HTMLAttributes<HTMLSpanElement> {}

AsyncValidatedInputRoot

value
DeclarationView source
AsyncValidatedInputRootts
export declare const AsyncValidatedInputRoot: import("react").ForwardRefExoticComponent<AsyncValidatedInputRootProps & import("react").RefAttributes<HTMLDivElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

AsyncValidatedInputRootProps

interface
DeclarationView source
AsyncValidatedInputRootPropsts
interface AsyncValidatedInputRootProps extends Omit<HTMLAttributes<HTMLDivElement>, "defaultValue" | "id">, AsyncValidatedInputInput$1, UseAsyncValidatedInputOptions {
  readonly children?: ReactNode;
}
Name
Kind
Type
Requirement
children
property
ReactNode
optional
Name
children
Kind
property
Type
ReactNode
Requirement
optional

AsyncValidatedInputRootProvider

value
DeclarationView source
AsyncValidatedInputRootProviderts
export declare const AsyncValidatedInputRootProvider: import("react").ForwardRefExoticComponent<AsyncValidatedInputRootProviderProps & import("react").RefAttributes<HTMLDivElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

AsyncValidatedInputRootProviderProps

interface
DeclarationView source
AsyncValidatedInputRootProviderPropsts
interface AsyncValidatedInputRootProviderProps extends Omit<HTMLAttributes<HTMLDivElement>, "defaultValue" | "id" | "value"> {
  readonly value: UseAsyncValidatedInputResult;
  readonly children?: ReactNode;
}
Name
Kind
Type
Requirement
children
property
ReactNode
optional
value
property
UseAsyncValidatedInputResult
required
Name
children
Kind
property
Type
ReactNode
Requirement
optional
Name
value
Kind
property
Type
UseAsyncValidatedInputResult
Requirement
required

AsyncValidatedInputSubmit

value
DeclarationView source
AsyncValidatedInputSubmitts
export declare const AsyncValidatedInputSubmit: import("react").ForwardRefExoticComponent<AsyncValidatedInputSubmitProps & import("react").RefAttributes<HTMLButtonElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

AsyncValidatedInputSubmitProps

interface
DeclarationView source
AsyncValidatedInputSubmitPropsts
interface AsyncValidatedInputSubmitProps extends ButtonHTMLAttributes<HTMLButtonElement> {}

Input

value
DeclarationView source
Inputts
export declare const Input: import("react").ForwardRefExoticComponent<AsyncValidatedInputInputProps & import("react").RefAttributes<HTMLInputElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

Message

value
DeclarationView source
Messagets
export declare const Message: import("react").ForwardRefExoticComponent<AsyncValidatedInputMessageProps & import("react").RefAttributes<HTMLSpanElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

Root

value
DeclarationView source
Rootts
export declare const Root: import("react").ForwardRefExoticComponent<AsyncValidatedInputRootProps & import("react").RefAttributes<HTMLDivElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

RootProvider

value
DeclarationView source
RootProviderts
export declare const RootProvider: import("react").ForwardRefExoticComponent<AsyncValidatedInputRootProviderProps & import("react").RefAttributes<HTMLDivElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

Submit

value
DeclarationView source
Submitts
export declare const Submit: import("react").ForwardRefExoticComponent<AsyncValidatedInputSubmitProps & import("react").RefAttributes<HTMLButtonElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

useAsyncValidatedInput

function
DeclarationView source
useAsyncValidatedInputts
declare function useAsyncValidatedInput(input: AsyncValidatedInputInput, options?: UseAsyncValidatedInputOptions): UseAsyncValidatedInputResult;
Name
Kind
Type
Requirement
input
parameter
AsyncValidatedInputInput
required
options
parameter
UseAsyncValidatedInputOptions
optional
return
return value
UseAsyncValidatedInputResult
n/a
Name
input
Kind
parameter
Type
AsyncValidatedInputInput
Requirement
required
Name
options
Kind
parameter
Type
UseAsyncValidatedInputOptions
Requirement
optional
Name
return
Kind
return value
Type
UseAsyncValidatedInputResult
Requirement
n/a

UseAsyncValidatedInputOptions

interface
DeclarationView source
UseAsyncValidatedInputOptionsts
interface UseAsyncValidatedInputOptions extends AsyncValidatedInputConnectOptions {
  readonly id?: string;
}
Name
Kind
Type
Requirement
id
property
string
optional
Name
id
Kind
property
Type
string
Requirement
optional

UseAsyncValidatedInputResult

interface
DeclarationView source
UseAsyncValidatedInputResultts
interface UseAsyncValidatedInputResult {
  readonly service: AsyncValidatedInputService;
  readonly connector: AsyncValidatedInputApi;
  readonly scope: PartScope;
  readonly snapshot: AsyncValidatedInputSnapshot;
}
Name
Kind
Type
Requirement
connector
property
AsyncValidatedInputApi
required
scope
property
PartScope
required
service
property
AsyncValidatedInputService
required
snapshot
property
AsyncValidatedInputSnapshot
required
Name
connector
Kind
property
Type
AsyncValidatedInputApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
AsyncValidatedInputService
Requirement
required
Name
snapshot
Kind
property
Type
AsyncValidatedInputSnapshot
Requirement
required

@grassroot/ui-headless-vue/async-validated-input

Vue adapter

13 exports
View source packages/ui-headless/vue/src/async-validated-input/index.ts

AsyncValidatedInputInput

value
DeclarationView source
AsyncValidatedInputInputts
export declare const AsyncValidatedInputInput: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

AsyncValidatedInputMessage

value
DeclarationView source
AsyncValidatedInputMessagets
export declare const AsyncValidatedInputMessage: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

AsyncValidatedInputOptions

type
DeclarationView source
AsyncValidatedInputOptionsts
type AsyncValidatedInputOptions = AsyncValidatedInputConnectOptions & {
  readonly id?: string;
};
Name
Kind
Type
Requirement
id
property
string
optional
Name
id
Kind
property
Type
string
Requirement
optional

AsyncValidatedInputRoot

value
DeclarationView source
AsyncValidatedInputRootts
export declare const AsyncValidatedInputRoot: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  defaultValue: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  pending: {
    type: PropType<boolean | undefined>;
    default: undefined;
  };
  status: {
    type: PropType<AsyncValidatedInputStatus | undefined>;
    default: undefined;
  };
  ariaLabel: StringConstructor;
  message: StringConstructor;
  id: StringConstructor;
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  valueChange: (_detail: AsyncValidatedInputValueChangeDetail) => true;
  validate: (_detail: AsyncValidatedInputValidateDetail) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  defaultValue: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  pending: {
    type: PropType<boolean | undefined>;
    default: undefined;
  };
  status: {
    type: PropType<AsyncValidatedInputStatus | undefined>;
    default: undefined;
  };
  ariaLabel: StringConstructor;
  message: StringConstructor;
  id: StringConstructor;
}>> & Readonly<{
  onValidate?: ((_detail: AsyncValidatedInputValidateDetail) => any) | undefined;
  onValueChange?: ((_detail: AsyncValidatedInputValueChangeDetail) => any) | undefined;
}>, {
  asChild: boolean;
  value: string | undefined;
  defaultValue: string | undefined;
  pending: boolean | undefined;
  status: AsyncValidatedInputStatus | undefined;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

AsyncValidatedInputRootProvider

value
DeclarationView source
AsyncValidatedInputRootProviderts
export declare const AsyncValidatedInputRootProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  value: {
    type: PropType<UseAsyncValidatedInputResult>;
    required: true;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  value: {
    type: PropType<UseAsyncValidatedInputResult>;
    required: true;
  };
}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

AsyncValidatedInputSubmit

value
DeclarationView source
AsyncValidatedInputSubmitts
export declare const AsyncValidatedInputSubmit: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

Input

value
DeclarationView source
Inputts
export declare const Input: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

Message

value
DeclarationView source
Messagets
export declare const Message: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

Root

value
DeclarationView source
Rootts
export declare const Root: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  defaultValue: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  pending: {
    type: PropType<boolean | undefined>;
    default: undefined;
  };
  status: {
    type: PropType<AsyncValidatedInputStatus | undefined>;
    default: undefined;
  };
  ariaLabel: StringConstructor;
  message: StringConstructor;
  id: StringConstructor;
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  valueChange: (_detail: AsyncValidatedInputValueChangeDetail) => true;
  validate: (_detail: AsyncValidatedInputValidateDetail) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  defaultValue: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  pending: {
    type: PropType<boolean | undefined>;
    default: undefined;
  };
  status: {
    type: PropType<AsyncValidatedInputStatus | undefined>;
    default: undefined;
  };
  ariaLabel: StringConstructor;
  message: StringConstructor;
  id: StringConstructor;
}>> & Readonly<{
  onValidate?: ((_detail: AsyncValidatedInputValidateDetail) => any) | undefined;
  onValueChange?: ((_detail: AsyncValidatedInputValueChangeDetail) => any) | undefined;
}>, {
  asChild: boolean;
  value: string | undefined;
  defaultValue: string | undefined;
  pending: boolean | undefined;
  status: AsyncValidatedInputStatus | undefined;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

RootProvider

value
DeclarationView source
RootProviderts
export declare const RootProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  value: {
    type: PropType<UseAsyncValidatedInputResult>;
    required: true;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  value: {
    type: PropType<UseAsyncValidatedInputResult>;
    required: true;
  };
}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

Submit

value
DeclarationView source
Submitts
export declare const Submit: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

useAsyncValidatedInput

function
DeclarationView source
useAsyncValidatedInputts
declare function useAsyncValidatedInput(input: () => AsyncValidatedInputInput, options?: () => AsyncValidatedInputOptions): UseAsyncValidatedInputResult;
Name
Kind
Type
Requirement
input
parameter
() => AsyncValidatedInputInput
required
options
parameter
() => AsyncValidatedInputOptions
optional
return
return value
UseAsyncValidatedInputResult
n/a
Name
input
Kind
parameter
Type
() => AsyncValidatedInputInput
Requirement
required
Name
options
Kind
parameter
Type
() => AsyncValidatedInputOptions
Requirement
optional
Name
return
Kind
return value
Type
UseAsyncValidatedInputResult
Requirement
n/a

UseAsyncValidatedInputResult

interface
DeclarationView source
UseAsyncValidatedInputResultts
interface UseAsyncValidatedInputResult {
  readonly service: AsyncValidatedInputService;
  readonly connector: AsyncValidatedInputApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<AsyncValidatedInputSnapshot>;
}
Name
Kind
Type
Requirement
connector
property
AsyncValidatedInputApi
required
scope
property
PartScope
required
service
property
AsyncValidatedInputService
required
snapshot
property
ShallowRef<AsyncValidatedInputSnapshot>
required
Name
connector
Kind
property
Type
AsyncValidatedInputApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
AsyncValidatedInputService
Requirement
required
Name
snapshot
Kind
property
Type
ShallowRef<AsyncValidatedInputSnapshot>
Requirement
required

@grassroot/ui-headless-angular/async-validated-input

Angular adapter

12 exports
View source packages/ui-headless/angular/src/async-validated-input/index.ts

AsyncValidatedInputStore

interface
DeclarationView source
AsyncValidatedInputStorets
export interface AsyncValidatedInputStore {
    readonly service: AsyncValidatedInputService;
    readonly connector: AsyncValidatedInputApi;
    readonly scope: PartScope;
    readonly version: WritableSignal<number>;
    start(): void;
    stop(): void;
    sync(input: Record<string, unknown>): void;
    syncOptions(options: Record<string, unknown>): void;
}
Name
Kind
Type
Requirement
connector
property
AsyncValidatedInputApi
required
scope
property
PartScope
required
service
property
AsyncValidatedInputService
required
start
method
() => void
required
stop
method
() => void
required
sync
method
(input: Record<string, unknown>) => void
required
syncOptions
method
(options: Record<string, unknown>) => void
required
version
property
WritableSignal<number>
required
Name
connector
Kind
property
Type
AsyncValidatedInputApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
AsyncValidatedInputService
Requirement
required
Name
start
Kind
method
Type
() => void
Requirement
required
Name
stop
Kind
method
Type
() => void
Requirement
required
Name
sync
Kind
method
Type
(input: Record<string, unknown>) => void
Requirement
required
Name
syncOptions
Kind
method
Type
(options: Record<string, unknown>) => void
Requirement
required
Name
version
Kind
property
Type
WritableSignal<number>
Requirement
required

createAsyncValidatedInputStore

function
DeclarationView source
createAsyncValidatedInputStorets
export declare function createAsyncValidatedInputStore(initial: AsyncValidatedInputInput, options?: AsyncValidatedInputConnectOptions): AsyncValidatedInputStore;
Name
Kind
Type
Requirement
initial
parameter
AsyncValidatedInputInput
required
options
parameter
AsyncValidatedInputConnectOptions
optional
return
return value
AsyncValidatedInputStore
n/a
Name
initial
Kind
parameter
Type
AsyncValidatedInputInput
Requirement
required
Name
options
Kind
parameter
Type
AsyncValidatedInputConnectOptions
Requirement
optional
Name
return
Kind
return value
Type
AsyncValidatedInputStore
Requirement
n/a

GrAsyncValidatedInputInput

class
DeclarationView source
GrAsyncValidatedInputInputts
export declare class GrAsyncValidatedInputInput implements OnDestroy {
    private readonly store;
    private readonly element;
    private readonly listeners;
    private readonly consumer;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputInput, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrAsyncValidatedInputInput, "[grAsyncValidatedInputInput]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumer
property
any
required
element
property
any
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrAsyncValidatedInputInput, "[grAsyncValidatedInputInput]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputInput, never>
required
store
property
any
required
Name
consumer
Kind
property
Type
any
Requirement
required
Name
element
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrAsyncValidatedInputInput, "[grAsyncValidatedInputInput]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputInput, never>
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

GrAsyncValidatedInputMessage

class
DeclarationView source
GrAsyncValidatedInputMessagets
export declare class GrAsyncValidatedInputMessage implements OnDestroy {
    private readonly store;
    private readonly element;
    private readonly listeners;
    private readonly consumer;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputMessage, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrAsyncValidatedInputMessage, "[grAsyncValidatedInputMessage]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumer
property
any
required
element
property
any
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrAsyncValidatedInputMessage, "[grAsyncValidatedInputMessage]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputMessage, never>
required
store
property
any
required
Name
consumer
Kind
property
Type
any
Requirement
required
Name
element
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrAsyncValidatedInputMessage, "[grAsyncValidatedInputMessage]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputMessage, never>
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

GrAsyncValidatedInputRoot

class
DeclarationView source
GrAsyncValidatedInputRootts
export declare class GrAsyncValidatedInputRoot implements OnDestroy {
    readonly value: import("@angular/core").InputSignal<string | undefined>;
    readonly defaultValue: import("@angular/core").InputSignal<string | undefined>;
    readonly pending: import("@angular/core").InputSignal<boolean | undefined>;
    readonly status: import("@angular/core").InputSignal<AsyncValidatedInputStatus | undefined>;
    readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
    readonly message: import("@angular/core").InputSignal<string | undefined>;
    readonly valueChange: import("@angular/core").OutputEmitterRef<AsyncValidatedInputValueChangeDetail>;
    readonly validate: import("@angular/core").OutputEmitterRef<AsyncValidatedInputValidateDetail>;
    readonly store: AsyncValidatedInputStore;
    private readonly host;
    private readonly listeners;
    private readonly consumer;
    private last;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputRoot, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GrAsyncValidatedInputRoot, "gr-async-validated-input-root", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "pending": { "alias": "pending"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "validate": "validate"; }, never, ["*"], true, never>;
}
Name
Kind
Type
Requirement
ariaLabel
property
import("@angular/core").InputSignal<string | undefined>
required
consumer
property
any
required
defaultValue
property
import("@angular/core").InputSignal<string | undefined>
required
host
property
any
required
last
property
any
required
listeners
property
any
required
message
property
import("@angular/core").InputSignal<string | undefined>
required
ngOnDestroy
method
() => void
required
ɵcmp
property
i0.ɵɵComponentDeclaration<GrAsyncValidatedInputRoot, "gr-async-validated-input-root", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "pending": { "alias": "pending"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "validate": "validate"; }, never, ["*"], true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputRoot, never>
required
pending
property
import("@angular/core").InputSignal<boolean | undefined>
required
status
property
import("@angular/core").InputSignal<AsyncValidatedInputStatus | undefined>
required
store
property
AsyncValidatedInputStore
required
validate
property
import("@angular/core").OutputEmitterRef<AsyncValidatedInputValidateDetail>
required
Name
ariaLabel
Kind
property
Type
import("@angular/core").InputSignal<string | undefined>
Requirement
required
Name
consumer
Kind
property
Type
any
Requirement
required
Name
defaultValue
Kind
property
Type
import("@angular/core").InputSignal<string | undefined>
Requirement
required
Name
host
Kind
property
Type
any
Requirement
required
Name
last
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
message
Kind
property
Type
import("@angular/core").InputSignal<string | undefined>
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵcmp
Kind
property
Type
i0.ɵɵComponentDeclaration<GrAsyncValidatedInputRoot, "gr-async-validated-input-root", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "pending": { "alias": "pending"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "validate": "validate"; }, never, ["*"], true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputRoot, never>
Requirement
required
Name
pending
Kind
property
Type
import("@angular/core").InputSignal<boolean | undefined>
Requirement
required
Name
status
Kind
property
Type
import("@angular/core").InputSignal<AsyncValidatedInputStatus | undefined>
Requirement
required
Name
store
Kind
property
Type
AsyncValidatedInputStore
Requirement
required
Name
validate
Kind
property
Type
import("@angular/core").OutputEmitterRef<AsyncValidatedInputValidateDetail>
Requirement
required
Name
value
Kind
property
Type
import("@angular/core").InputSignal<string | undefined>
Requirement
required
Name
valueChange
Kind
property
Type
import("@angular/core").OutputEmitterRef<AsyncValidatedInputValueChangeDetail>
Requirement
required

GrAsyncValidatedInputRootProvider

class
DeclarationView source
GrAsyncValidatedInputRootProviderts
export declare class GrAsyncValidatedInputRootProvider implements OnDestroy {
    private readonly store;
    private readonly host;
    private readonly listeners;
    private readonly consumer;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputRootProvider, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GrAsyncValidatedInputRootProvider, "gr-async-validated-input-root-provider", never, {}, {}, never, ["*"], true, never>;
}
Name
Kind
Type
Requirement
consumer
property
any
required
host
property
any
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵcmp
property
i0.ɵɵComponentDeclaration<GrAsyncValidatedInputRootProvider, "gr-async-validated-input-root-provider", never, {}, {}, never, ["*"], true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputRootProvider, never>
required
store
property
any
required
Name
consumer
Kind
property
Type
any
Requirement
required
Name
host
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵcmp
Kind
property
Type
i0.ɵɵComponentDeclaration<GrAsyncValidatedInputRootProvider, "gr-async-validated-input-root-provider", never, {}, {}, never, ["*"], true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputRootProvider, never>
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

GrAsyncValidatedInputSubmit

class
DeclarationView source
GrAsyncValidatedInputSubmitts
export declare class GrAsyncValidatedInputSubmit implements OnDestroy {
    private readonly store;
    private readonly element;
    private readonly listeners;
    private readonly consumer;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputSubmit, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrAsyncValidatedInputSubmit, "[grAsyncValidatedInputSubmit]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumer
property
any
required
element
property
any
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrAsyncValidatedInputSubmit, "[grAsyncValidatedInputSubmit]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputSubmit, never>
required
store
property
any
required
Name
consumer
Kind
property
Type
any
Requirement
required
Name
element
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrAsyncValidatedInputSubmit, "[grAsyncValidatedInputSubmit]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputSubmit, never>
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

Input

class
DeclarationView source
Inputts
export declare class GrAsyncValidatedInputInput implements OnDestroy {
    private readonly store;
    private readonly element;
    private readonly listeners;
    private readonly consumer;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputInput, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrAsyncValidatedInputInput, "[grAsyncValidatedInputInput]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumer
property
any
required
element
property
any
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrAsyncValidatedInputInput, "[grAsyncValidatedInputInput]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputInput, never>
required
store
property
any
required
Name
consumer
Kind
property
Type
any
Requirement
required
Name
element
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrAsyncValidatedInputInput, "[grAsyncValidatedInputInput]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputInput, never>
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

Message

class
DeclarationView source
Messagets
export declare class GrAsyncValidatedInputMessage implements OnDestroy {
    private readonly store;
    private readonly element;
    private readonly listeners;
    private readonly consumer;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputMessage, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrAsyncValidatedInputMessage, "[grAsyncValidatedInputMessage]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumer
property
any
required
element
property
any
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrAsyncValidatedInputMessage, "[grAsyncValidatedInputMessage]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputMessage, never>
required
store
property
any
required
Name
consumer
Kind
property
Type
any
Requirement
required
Name
element
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrAsyncValidatedInputMessage, "[grAsyncValidatedInputMessage]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputMessage, never>
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

Root

class
DeclarationView source
Rootts
export declare class GrAsyncValidatedInputRoot implements OnDestroy {
    readonly value: import("@angular/core").InputSignal<string | undefined>;
    readonly defaultValue: import("@angular/core").InputSignal<string | undefined>;
    readonly pending: import("@angular/core").InputSignal<boolean | undefined>;
    readonly status: import("@angular/core").InputSignal<AsyncValidatedInputStatus | undefined>;
    readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
    readonly message: import("@angular/core").InputSignal<string | undefined>;
    readonly valueChange: import("@angular/core").OutputEmitterRef<AsyncValidatedInputValueChangeDetail>;
    readonly validate: import("@angular/core").OutputEmitterRef<AsyncValidatedInputValidateDetail>;
    readonly store: AsyncValidatedInputStore;
    private readonly host;
    private readonly listeners;
    private readonly consumer;
    private last;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputRoot, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GrAsyncValidatedInputRoot, "gr-async-validated-input-root", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "pending": { "alias": "pending"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "validate": "validate"; }, never, ["*"], true, never>;
}
Name
Kind
Type
Requirement
ariaLabel
property
import("@angular/core").InputSignal<string | undefined>
required
consumer
property
any
required
defaultValue
property
import("@angular/core").InputSignal<string | undefined>
required
host
property
any
required
last
property
any
required
listeners
property
any
required
message
property
import("@angular/core").InputSignal<string | undefined>
required
ngOnDestroy
method
() => void
required
ɵcmp
property
i0.ɵɵComponentDeclaration<GrAsyncValidatedInputRoot, "gr-async-validated-input-root", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "pending": { "alias": "pending"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "validate": "validate"; }, never, ["*"], true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputRoot, never>
required
pending
property
import("@angular/core").InputSignal<boolean | undefined>
required
status
property
import("@angular/core").InputSignal<AsyncValidatedInputStatus | undefined>
required
store
property
AsyncValidatedInputStore
required
validate
property
import("@angular/core").OutputEmitterRef<AsyncValidatedInputValidateDetail>
required
Name
ariaLabel
Kind
property
Type
import("@angular/core").InputSignal<string | undefined>
Requirement
required
Name
consumer
Kind
property
Type
any
Requirement
required
Name
defaultValue
Kind
property
Type
import("@angular/core").InputSignal<string | undefined>
Requirement
required
Name
host
Kind
property
Type
any
Requirement
required
Name
last
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
message
Kind
property
Type
import("@angular/core").InputSignal<string | undefined>
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵcmp
Kind
property
Type
i0.ɵɵComponentDeclaration<GrAsyncValidatedInputRoot, "gr-async-validated-input-root", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "pending": { "alias": "pending"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "validate": "validate"; }, never, ["*"], true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputRoot, never>
Requirement
required
Name
pending
Kind
property
Type
import("@angular/core").InputSignal<boolean | undefined>
Requirement
required
Name
status
Kind
property
Type
import("@angular/core").InputSignal<AsyncValidatedInputStatus | undefined>
Requirement
required
Name
store
Kind
property
Type
AsyncValidatedInputStore
Requirement
required
Name
validate
Kind
property
Type
import("@angular/core").OutputEmitterRef<AsyncValidatedInputValidateDetail>
Requirement
required
Name
value
Kind
property
Type
import("@angular/core").InputSignal<string | undefined>
Requirement
required
Name
valueChange
Kind
property
Type
import("@angular/core").OutputEmitterRef<AsyncValidatedInputValueChangeDetail>
Requirement
required

RootProvider

class
DeclarationView source
RootProviderts
export declare class GrAsyncValidatedInputRootProvider implements OnDestroy {
    private readonly store;
    private readonly host;
    private readonly listeners;
    private readonly consumer;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputRootProvider, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GrAsyncValidatedInputRootProvider, "gr-async-validated-input-root-provider", never, {}, {}, never, ["*"], true, never>;
}
Name
Kind
Type
Requirement
consumer
property
any
required
host
property
any
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵcmp
property
i0.ɵɵComponentDeclaration<GrAsyncValidatedInputRootProvider, "gr-async-validated-input-root-provider", never, {}, {}, never, ["*"], true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputRootProvider, never>
required
store
property
any
required
Name
consumer
Kind
property
Type
any
Requirement
required
Name
host
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵcmp
Kind
property
Type
i0.ɵɵComponentDeclaration<GrAsyncValidatedInputRootProvider, "gr-async-validated-input-root-provider", never, {}, {}, never, ["*"], true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputRootProvider, never>
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

Submit

class
DeclarationView source
Submitts
export declare class GrAsyncValidatedInputSubmit implements OnDestroy {
    private readonly store;
    private readonly element;
    private readonly listeners;
    private readonly consumer;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputSubmit, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrAsyncValidatedInputSubmit, "[grAsyncValidatedInputSubmit]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumer
property
any
required
element
property
any
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrAsyncValidatedInputSubmit, "[grAsyncValidatedInputSubmit]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputSubmit, never>
required
store
property
any
required
Name
consumer
Kind
property
Type
any
Requirement
required
Name
element
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrAsyncValidatedInputSubmit, "[grAsyncValidatedInputSubmit]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrAsyncValidatedInputSubmit, never>
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

@grassroot/ui-headless-svelte/async-validated-input

Svelte adapter

13 exports
View source packages/ui-headless/svelte/src/async-validated-input/index.ts

AsyncValidatedInputInput

value
DeclarationView source
AsyncValidatedInputInputts
export declare const AsyncValidatedInputInput: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

AsyncValidatedInputMessage

value
DeclarationView source
AsyncValidatedInputMessagets
export declare const AsyncValidatedInputMessage: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

AsyncValidatedInputRoot

value
DeclarationView source
AsyncValidatedInputRootts
export declare const AsyncValidatedInputRoot: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

AsyncValidatedInputRootProvider

value
DeclarationView source
AsyncValidatedInputRootProviderts
export declare const AsyncValidatedInputRootProvider: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

AsyncValidatedInputSubmit

value
DeclarationView source
AsyncValidatedInputSubmitts
export declare const AsyncValidatedInputSubmit: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

createAsyncValidatedInput

function
DeclarationView source
createAsyncValidatedInputts
export declare function createAsyncValidatedInput(input: () => AsyncValidatedInputInput, options?: UseAsyncValidatedInputOptions): UseAsyncValidatedInputResult;
Name
Kind
Type
Requirement
input
parameter
() => AsyncValidatedInputInput
required
options
parameter
UseAsyncValidatedInputOptions
optional
return
return value
UseAsyncValidatedInputResult
n/a
Name
input
Kind
parameter
Type
() => AsyncValidatedInputInput
Requirement
required
Name
options
Kind
parameter
Type
UseAsyncValidatedInputOptions
Requirement
optional
Name
return
Kind
return value
Type
UseAsyncValidatedInputResult
Requirement
n/a

Input

value
DeclarationView source
Inputts
export declare const Input: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

Message

value
DeclarationView source
Messagets
export declare const Message: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

Root

value
DeclarationView source
Rootts
export declare const Root: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

RootProvider

value
DeclarationView source
RootProviderts
export declare const RootProvider: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

Submit

value
DeclarationView source
Submitts
export declare const Submit: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

UseAsyncValidatedInputOptions

interface
DeclarationView source
UseAsyncValidatedInputOptionsts
export interface UseAsyncValidatedInputOptions extends AsyncValidatedInputConnectOptions {
    readonly id?: string;
}
Name
Kind
Type
Requirement
id
property
string
optional
Name
id
Kind
property
Type
string
Requirement
optional

UseAsyncValidatedInputResult

interface
DeclarationView source
UseAsyncValidatedInputResultts
export interface UseAsyncValidatedInputResult {
    readonly service: AsyncValidatedInputService;
    readonly connector: AsyncValidatedInputApi;
    readonly scope: PartScope;
    readonly version: () => number;
}
Name
Kind
Type
Requirement
connector
property
AsyncValidatedInputApi
required
scope
property
PartScope
required
service
property
AsyncValidatedInputService
required
version
property
() => number
required
Name
connector
Kind
property
Type
AsyncValidatedInputApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
AsyncValidatedInputService
Requirement
required
Name
version
Kind
property
Type
() => number
Requirement
required

@grassroot/ui-headless-solid/async-validated-input

Solid adapter

15 exports
View source packages/ui-headless/solid/src/async-validated-input/index.ts

AsyncValidatedInputInput

function
DeclarationView source
AsyncValidatedInputInputts
export declare function AsyncValidatedInputInput(props: JSX.InputHTMLAttributes<HTMLInputElement>): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.InputHTMLAttributes<HTMLInputElement>
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.InputHTMLAttributes<HTMLInputElement>
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

AsyncValidatedInputMessage

function
DeclarationView source
AsyncValidatedInputMessagets
export declare function AsyncValidatedInputMessage(props: JSX.HTMLAttributes<HTMLSpanElement>): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.HTMLAttributes<HTMLSpanElement>
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.HTMLAttributes<HTMLSpanElement>
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

AsyncValidatedInputRoot

function
DeclarationView source
AsyncValidatedInputRootts
export declare function AsyncValidatedInputRoot(props: AsyncValidatedInputRootProps): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
AsyncValidatedInputRootProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
AsyncValidatedInputRootProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

AsyncValidatedInputRootProps

interface
DeclarationView source
AsyncValidatedInputRootPropsts
export interface AsyncValidatedInputRootProps extends Omit<JSX.HTMLAttributes<HTMLDivElement>, "id" | "value" | "onInput" | "onChange">, AsyncValidatedInputInput, AsyncValidatedInputConnectOptions {
    readonly id?: string;
    readonly children?: JSX.Element;
}
Name
Kind
Type
Requirement
children
property
JSX.Element
optional
id
property
string
optional
Name
children
Kind
property
Type
JSX.Element
Requirement
optional
Name
id
Kind
property
Type
string
Requirement
optional

AsyncValidatedInputRootProvider

function
DeclarationView source
AsyncValidatedInputRootProviderts
export declare function AsyncValidatedInputRootProvider(props: AsyncValidatedInputRootProviderProps): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
AsyncValidatedInputRootProviderProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
AsyncValidatedInputRootProviderProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

AsyncValidatedInputRootProviderProps

interface
DeclarationView source
AsyncValidatedInputRootProviderPropsts
export interface AsyncValidatedInputRootProviderProps extends JSX.HTMLAttributes<HTMLDivElement> {
    readonly value: UseAsyncValidatedInputResult;
    readonly children?: JSX.Element;
}
Name
Kind
Type
Requirement
children
property
JSX.Element
optional
value
property
UseAsyncValidatedInputResult
required
Name
children
Kind
property
Type
JSX.Element
Requirement
optional
Name
value
Kind
property
Type
UseAsyncValidatedInputResult
Requirement
required

AsyncValidatedInputSubmit

function
DeclarationView source
AsyncValidatedInputSubmitts
export declare function AsyncValidatedInputSubmit(props: JSX.ButtonHTMLAttributes<HTMLButtonElement>): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.ButtonHTMLAttributes<HTMLButtonElement>
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.ButtonHTMLAttributes<HTMLButtonElement>
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

Input

function
DeclarationView source
Inputts
export declare function AsyncValidatedInputInput(props: JSX.InputHTMLAttributes<HTMLInputElement>): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.InputHTMLAttributes<HTMLInputElement>
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.InputHTMLAttributes<HTMLInputElement>
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

Message

function
DeclarationView source
Messagets
export declare function AsyncValidatedInputMessage(props: JSX.HTMLAttributes<HTMLSpanElement>): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.HTMLAttributes<HTMLSpanElement>
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.HTMLAttributes<HTMLSpanElement>
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

Root

function
DeclarationView source
Rootts
export declare function AsyncValidatedInputRoot(props: AsyncValidatedInputRootProps): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
AsyncValidatedInputRootProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
AsyncValidatedInputRootProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

RootProvider

function
DeclarationView source
RootProviderts
export declare function AsyncValidatedInputRootProvider(props: AsyncValidatedInputRootProviderProps): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
AsyncValidatedInputRootProviderProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
AsyncValidatedInputRootProviderProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

Submit

function
DeclarationView source
Submitts
export declare function AsyncValidatedInputSubmit(props: JSX.ButtonHTMLAttributes<HTMLButtonElement>): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.ButtonHTMLAttributes<HTMLButtonElement>
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.ButtonHTMLAttributes<HTMLButtonElement>
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

useAsyncValidatedInput

function
DeclarationView source
useAsyncValidatedInputts
export declare function useAsyncValidatedInput(input: Accessor<AsyncValidatedInputInput>, options?: UseAsyncValidatedInputOptions): UseAsyncValidatedInputResult;
Name
Kind
Type
Requirement
input
parameter
Accessor<AsyncValidatedInputInput>
required
options
parameter
UseAsyncValidatedInputOptions
optional
return
return value
UseAsyncValidatedInputResult
n/a
Name
input
Kind
parameter
Type
Accessor<AsyncValidatedInputInput>
Requirement
required
Name
options
Kind
parameter
Type
UseAsyncValidatedInputOptions
Requirement
optional
Name
return
Kind
return value
Type
UseAsyncValidatedInputResult
Requirement
n/a

UseAsyncValidatedInputOptions

interface
DeclarationView source
UseAsyncValidatedInputOptionsts
export interface UseAsyncValidatedInputOptions extends AsyncValidatedInputConnectOptions {
    readonly id?: string;
}
Name
Kind
Type
Requirement
id
property
string
optional
Name
id
Kind
property
Type
string
Requirement
optional

UseAsyncValidatedInputResult

interface
DeclarationView source
UseAsyncValidatedInputResultts
export interface UseAsyncValidatedInputResult {
    readonly service: AsyncValidatedInputService;
    readonly connector: AsyncValidatedInputApi;
    readonly scope: PartScope;
    readonly snapshot: () => number;
}
Name
Kind
Type
Requirement
connector
property
AsyncValidatedInputApi
required
scope
property
PartScope
required
service
property
AsyncValidatedInputService
required
snapshot
property
() => number
required
Name
connector
Kind
property
Type
AsyncValidatedInputApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
AsyncValidatedInputService
Requirement
required
Name
snapshot
Kind
property
Type
() => number
Requirement
required