@getodk/xforms-engine 0.6.0 → 0.7.0

package/dist/client/repeat/RepeatInstanceNode.d.ts

@@ -1,5 +1,4 @@
-import { RepeatInstanceDefinition } from '../../parse/model/RepeatInstanceDefinition.ts';
-import { RepeatTemplateDefinition } from '../../parse/model/RepeatTemplateDefinition.ts';
+import { AnyRepeatDefinition } from '../../parse/model/RepeatDefinition.ts';
 import { BaseNode, BaseNodeState } from '../BaseNode.ts';
 import { GeneralChildNode, RepeatRangeNode } from '../hierarchy.ts';
 import { NodeAppearances } from '../NodeAppearances.ts';
@@ -11,12 +10,12 @@ export interface RepeatInstanceNodeState extends BaseNodeState {
     get valueOptions(): null;
     get value(): null;
 }
-export type RepeatDefinition = RepeatInstanceDefinition | RepeatTemplateDefinition;
-export type RepeatInstanceNodeAppearances = NodeAppearances<RepeatDefinition>;
+export type { AnyRepeatDefinition };
+export type RepeatInstanceNodeAppearances = NodeAppearances<AnyRepeatDefinition>;
 export interface RepeatInstanceNode extends BaseNode {
     readonly nodeType: 'repeat-instance';
     readonly appearances: RepeatInstanceNodeAppearances;
-    readonly definition: RepeatDefinition;
+    readonly definition: AnyRepeatDefinition;
     readonly root: RootNode;
     /**
      * A repeat instance may only be a child of a {@link RepeatRangeNode}.

package/dist/client/repeat/RepeatRangeControlledNode.d.ts

@@ -1,4 +1,4 @@
-import { ControlledRepeatRangeDefinition } from '../../parse/model/RepeatRangeDefinition.ts';
+import { ControlledRepeatDefinition } from '../../parse/model/RepeatDefinition.ts';
 import { BaseRepeatRangeNode, BaseRepeatRangeNodeState } from './BaseRepeatRangeNode.ts';
 /**
  * {@inheritDoc BaseRepeatRangeNodeState}
@@ -14,5 +14,5 @@ export interface RepeatRangeControlledState extends BaseRepeatRangeNodeState {
  */
 export interface RepeatRangeControlledNode extends BaseRepeatRangeNode {
     readonly nodeType: 'repeat-range:controlled';
-    readonly definition: ControlledRepeatRangeDefinition;
+    readonly definition: ControlledRepeatDefinition;
 }

package/dist/client/repeat/RepeatRangeUncontrolledNode.d.ts

@@ -1,4 +1,4 @@
-import { UncontrolledRepeatRangeDefinition } from '../../parse/model/RepeatRangeDefinition.ts';
+import { UncontrolledRepeatDefinition } from '../../parse/model/RepeatDefinition.ts';
 import { RootNode } from '../RootNode.ts';
 import { BaseRepeatRangeNode, BaseRepeatRangeNodeState } from './BaseRepeatRangeNode.ts';
 /**
@@ -13,7 +13,7 @@ export interface RepeatRangeUncontrolledState extends BaseRepeatRangeNodeState {
  */
 export interface RepeatRangeUncontrolledNode extends BaseRepeatRangeNode {
     readonly nodeType: 'repeat-range:uncontrolled';
-    readonly definition: UncontrolledRepeatRangeDefinition;
+    readonly definition: UncontrolledRepeatDefinition;
     addInstances(afterIndex?: number, count?: number): RootNode;
     removeInstances(startIndex: number, count?: number): RootNode;
 }

package/dist/client/resources.d.ts

@@ -65,7 +65,7 @@ export interface FetchResourceResponseHeaders {
  *
  * Furthermore, if the engine intends to read {@link body} (or its indirect
  * {@link blob} or {@link text} consumers), it will do so in the course of a
- * client's call to {@link initializeForm}, and before the
+ * client's call to {@link loadForm}, and before the
  * {@link Promise<PrimaryInstance>} returned by that call is resolved.
  */
 export interface FetchResourceResponse {

package/dist/client/serialization/InstanceData.d.ts

@@ -0,0 +1,12 @@
+import { INSTANCE_FILE_NAME, InstanceFile } from './InstanceFile.ts';
+export type InstanceAttachmentFileName = string;
+export interface InstanceData extends FormData {
+    get(name: INSTANCE_FILE_NAME): InstanceFile;
+    /**
+     * @todo Can we guarantee (both in static types and at runtime) that
+     * {@link InstanceData} only contains files?
+     */
+    get(name: InstanceAttachmentFileName): FormDataEntryValue | null;
+    has(name: INSTANCE_FILE_NAME): true;
+    has(name: InstanceAttachmentFileName): boolean;
+}

package/dist/client/serialization/InstanceFile.d.ts

@@ -0,0 +1,6 @@
+import { INSTANCE_FILE_NAME, INSTANCE_FILE_TYPE } from '../constants.ts';
+export type { INSTANCE_FILE_NAME, INSTANCE_FILE_TYPE };
+export interface InstanceFile extends File {
+    readonly name: INSTANCE_FILE_NAME;
+    readonly type: INSTANCE_FILE_TYPE;
+}

package/dist/client/serialization/InstancePayload.d.ts

@@ -0,0 +1,93 @@
+import { SubmissionMeta } from '../submission/SubmissionMeta.ts';
+import { DescendantNodeViolationReference } from '../validation.ts';
+import { InstanceData } from './InstanceData.ts';
+import { InstancePayloadType } from './InstancePayloadOptions.ts';
+export type InstancePayloadStatus = 'pending' | 'max-size-exceeded' | 'ready';
+type InstancePayloadData<PayloadType extends InstancePayloadType> = {
+    chunked: readonly [InstanceData, ...InstanceData[]];
+    monolithic: readonly [InstanceData];
+}[PayloadType];
+/**
+ * Provides detail about an individual instance attachment {@link File}s which
+ * exceeds the client-specified {@link maxSize} for a
+ * {@link ChunkedInstancePayload | chunked instance payload}. Clients may use
+ * this value to provide guidance to users.
+ *
+ * @todo We may want to consider (a) making {@link maxSize} a configuration the
+ * client can provide when initializing a form instance, rather than only when
+ * serializing an instance payload; and then (b) treating a maximum size
+ * violation as another kind of node-level violation. This would go beyond the
+ * kinds of validation specified by ODK XForms, but it would make a lot of
+ * _conceptual sense_.
+ *
+ * It would almost certainly be helpful to alert users to violations as the
+ * occur, rather than only at instance payload serialization time (where they
+ * have likely already moved on). This is something clients can do without
+ * engine support, but it would likely promote good usability patterns if the
+ * engine makes it an obvious and uniform option at the main engine/client
+ * entrypoint.
+ *
+ * @todo If we consider the above, we'd want to reframe _this interface_ to
+ * match the shape of other {@link AnyViolation | violations} (adding it as a
+ * member of that union). We'd also likely eliminate
+ * {@link MaxSizeExceededResult} in the process, since
+ * {@link PendingInstancePayload} would then cover the case.
+ */
+interface MaxSizeViolation {
+    /**
+     * Specifies the index of
+     * {@link InstancePayloadData<'chunked'> | chunked instance payload data}
+     * where an instance attachment {@link File} exceeds the client-specified
+     * {@link maxSize}.
+     */
+    readonly dataIndex: number;
+    /**
+     * Specifies the name of the file which exceeds the client-specified
+     * {@link maxSize}. This name can also be used as a key to access the
+     * violating {@link File}/instance attachment, in the {@link InstanceData} at
+     * the specified {@link dataIndex}.
+     */
+    readonly fileName: string;
+    /**
+     * Reflects the client-specified maximum size for each chunk of a
+     * {@link ChunkedInstancePayload | chunked instance payload}.
+     */
+    readonly maxSize: number;
+    /**
+     * Details the actual size of the violating {@link File}/instance attachment.
+     * Along with {@link maxSize}. Clients may use the delta between this value
+     * and {@link maxSize} to provide detailed guidance to users.
+     */
+    readonly actualSize: number;
+}
+type InstancePayloadViolation = DescendantNodeViolationReference | MaxSizeViolation;
+interface BaseInstancePayload<PayloadType extends InstancePayloadType> {
+    readonly payloadType: PayloadType;
+    readonly status: InstancePayloadStatus;
+    readonly submissionMeta: SubmissionMeta;
+    get violations(): readonly InstancePayloadViolation[] | null;
+    /**
+     * Instance attachment data may be chunked according to the
+     * {@link InstancePayloadOptions.maxSize | maxSize instance payload option}
+     */
+    readonly data: InstancePayloadData<PayloadType>;
+}
+interface PendingInstancePayload<PayloadType extends InstancePayloadType> extends BaseInstancePayload<PayloadType> {
+    readonly status: 'pending';
+    get violations(): readonly DescendantNodeViolationReference[];
+}
+interface MaxSizeExceededResult extends BaseInstancePayload<'chunked'> {
+    readonly status: 'max-size-exceeded';
+    get violations(): readonly MaxSizeViolation[];
+}
+interface ReadyInstancePayload<PayloadType extends InstancePayloadType> extends BaseInstancePayload<PayloadType> {
+    readonly status: 'ready';
+    get violations(): null;
+}
+export type ChunkedInstancePayload = MaxSizeExceededResult | PendingInstancePayload<'chunked'> | ReadyInstancePayload<'chunked'>;
+export type MonolithicInstancePayload = PendingInstancePayload<'monolithic'> | ReadyInstancePayload<'monolithic'>;
+export type InstancePayload<PayloadType extends InstancePayloadType> = {
+    chunked: ChunkedInstancePayload;
+    monolithic: MonolithicInstancePayload;
+}[PayloadType];
+export {};

package/dist/client/serialization/InstancePayloadOptions.d.ts

@@ -0,0 +1,23 @@
+export type InstancePayloadType = 'chunked' | 'monolithic';
+interface BaseInstancePayloadOptions<PayloadType extends InstancePayloadType> {
+    readonly payloadType?: PayloadType | undefined;
+    /**
+     * As described in the
+     * {@link https://docs.getodk.org/openrosa-form-submission/#extended-transmission-considerations | OpenRosa Form Submission API},
+     * clients may obtain this value from an OpenRosa server's
+     * `X-OpenRosa-Accept-Content-Length` header.
+     */
+    readonly maxSize?: number;
+}
+interface ChunkedInstancePayloadOptions extends BaseInstancePayloadOptions<'chunked'> {
+    readonly maxSize: number;
+}
+interface MonolithicInstancePayloadOptions extends BaseInstancePayloadOptions<'monolithic'> {
+    readonly payloadType?: 'monolithic' | undefined;
+    readonly maxSize?: never;
+}
+export type InstancePayloadOptions<PayloadType extends InstancePayloadType = 'monolithic'> = {
+    chunked: ChunkedInstancePayloadOptions;
+    monolithic: MonolithicInstancePayloadOptions;
+}[PayloadType];
+export {};

package/dist/client/serialization/InstanceState.d.ts

@@ -0,0 +1,12 @@
+export interface InstanceState {
+    /**
+     * Represents the serialized XML state of a given node. The value produced in
+     * {@link RootNode.instanceState} is the same serialization which will be
+     * produced for a complete instance.
+     *
+     * @todo Note that this particular aspect of the design doesn't yet address
+     * production of unique file names. As such, this may change as we introduce
+     * affected data types (and their supporting nodes).
+     */
+    get instanceXML(): string;
+}

package/dist/client/submission/{SubmissionDefinition.d.ts → SubmissionMeta.d.ts}

@@ -1,4 +1,4 @@
-export interface SubmissionDefinition {
+export interface SubmissionMeta {
     /**
      * @see {@link https://getodk.github.io/xforms-spec/#submission-attributes | `action` submission attribute}
      */

package/dist/entrypoints/FormInstance.d.ts

@@ -0,0 +1,20 @@
+import { FormInstance as ClientFormInstance, FormInstanceInitializationMode } from '../client/form/FormInstance.ts';
+import { FormInstanceConfig } from '../client/index.ts';
+import { BasePrimaryInstanceOptions, PrimaryInstanceInitialState } from '../instance/PrimaryInstance.ts';
+import { Root } from '../instance/Root.ts';
+import { FormSuccessResult } from './FormResult/FormSuccessResult.ts';
+import { FormWarningResult } from './FormResult/FormWarningResult.ts';
+export type InstantiableFormResult = FormSuccessResult | FormWarningResult;
+interface FormInstanceOptions<Mode extends FormInstanceInitializationMode> {
+    readonly mode: Mode;
+    readonly initialState: PrimaryInstanceInitialState<Mode>;
+    readonly instanceOptions: BasePrimaryInstanceOptions;
+    readonly instanceConfig: FormInstanceConfig;
+}
+export declare class FormInstance<Mode extends FormInstanceInitializationMode> implements ClientFormInstance<Mode> {
+    readonly formResult: InstantiableFormResult;
+    readonly mode: Mode;
+    readonly root: Root;
+    constructor(formResult: InstantiableFormResult, options: FormInstanceOptions<Mode>);
+}
+export {};

package/dist/entrypoints/FormResult/BaseFormResult.d.ts

@@ -0,0 +1,22 @@
+import { FormResultStatus, LoadFormFailureResult, LoadFormResult, LoadFormSuccessResult, LoadFormWarningResult } from '../../client/form/LoadFormResult.ts';
+interface LoadFormResultByStatus {
+    readonly success: LoadFormSuccessResult;
+    readonly warning: LoadFormWarningResult;
+    readonly failure: LoadFormFailureResult;
+}
+export type BaseFormResultProperty<Status extends FormResultStatus, Key extends keyof LoadFormResult> = LoadFormResultByStatus[Status][Key];
+export interface BaseFormResultOptions<Status extends FormResultStatus> {
+    readonly status: Status;
+    readonly warnings: BaseFormResultProperty<Status, 'warnings'>;
+    readonly error: BaseFormResultProperty<Status, 'error'>;
+}
+export declare abstract class BaseFormResult<Status extends FormResultStatus> {
+    readonly status: Status;
+    readonly warnings: BaseFormResultProperty<Status, 'warnings'>;
+    readonly error: BaseFormResultProperty<Status, 'error'>;
+    abstract readonly createInstance: BaseFormResultProperty<Status, 'createInstance'>;
+    abstract readonly editInstance: BaseFormResultProperty<Status, 'editInstance'>;
+    abstract readonly restoreInstance: BaseFormResultProperty<Status, 'restoreInstance'>;
+    constructor(options: BaseFormResultOptions<Status>);
+}
+export {};

package/dist/entrypoints/FormResult/BaseInstantiableFormResult.d.ts

@@ -0,0 +1,25 @@
+import { CreateFormInstance } from '../../client/form/CreateFormInstance.ts';
+import { EditFormInstance } from '../../client/form/EditFormInstance.ts';
+import { RestoreFormInstance } from '../../client/form/RestoreFormInstance.ts';
+import { BasePrimaryInstanceOptions } from '../../instance/PrimaryInstance.ts';
+import { FormResource } from '../../instance/resource.ts';
+import { ReactiveScope } from '../../lib/reactivity/scope.ts';
+import { InstantiableFormResult } from '../FormInstance.ts';
+import { BaseFormResultProperty, BaseFormResult } from './BaseFormResult.ts';
+export type InstantiableFormResultStatus = 'success' | 'warning';
+export interface BaseInstantiableFormResultOptions<Status extends InstantiableFormResultStatus> {
+    readonly status: Status;
+    readonly warnings: BaseFormResultProperty<Status, 'warnings'>;
+    readonly error: null;
+    readonly scope: ReactiveScope;
+    readonly formResource: FormResource;
+    readonly instanceOptions: BasePrimaryInstanceOptions;
+}
+export declare abstract class BaseInstantiableFormResult<Status extends InstantiableFormResultStatus> extends BaseFormResult<Status> {
+    readonly createInstance: CreateFormInstance;
+    readonly editInstance: EditFormInstance;
+    readonly restoreInstance: RestoreFormInstance;
+    constructor(options: BaseInstantiableFormResultOptions<Status>);
+    isInstantiable(): this is InstantiableFormResult;
+    assertInstantiable(): asserts this is InstantiableFormResult;
+}

package/dist/entrypoints/FormResult/FormFailureResult.d.ts

@@ -0,0 +1,17 @@
+import { CreateFormInstance } from '../../client/form/CreateFormInstance.ts';
+import { EditFormInstance } from '../../client/form/EditFormInstance.ts';
+import { FailedLoadFormResultMethod, LoadFormFailureResult, LoadFormWarnings } from '../../client/form/LoadFormResult.ts';
+import { RestoreFormInstance } from '../../client/form/RestoreFormInstance.ts';
+import { LoadFormFailureError } from '../../error/LoadFormFailureError.ts';
+import { BaseFormResult } from './BaseFormResult.ts';
+interface FormFailureOptions {
+    readonly error: LoadFormFailureError;
+    readonly warnings: LoadFormWarnings | null;
+}
+export declare class FormFailureResult extends BaseFormResult<'failure'> implements LoadFormFailureResult {
+    readonly createInstance: FailedLoadFormResultMethod<CreateFormInstance>;
+    readonly editInstance: FailedLoadFormResultMethod<EditFormInstance>;
+    readonly restoreInstance: FailedLoadFormResultMethod<RestoreFormInstance>;
+    constructor(options: FormFailureOptions);
+}
+export {};

package/dist/entrypoints/FormResult/FormSuccessResult.d.ts

@@ -0,0 +1,15 @@
+import { LoadFormSuccessResult } from '../../client/index.ts';
+import { BasePrimaryInstanceOptions } from '../../instance/PrimaryInstance.ts';
+import { FormResource } from '../../instance/resource.ts';
+import { ReactiveScope } from '../../lib/reactivity/scope.ts';
+import { BaseInstantiableFormResult } from './BaseInstantiableFormResult.ts';
+export interface FormSuccessResultOptions {
+    readonly warnings: null;
+    readonly error: null;
+    readonly scope: ReactiveScope;
+    readonly formResource: FormResource;
+    readonly instanceOptions: BasePrimaryInstanceOptions;
+}
+export declare class FormSuccessResult extends BaseInstantiableFormResult<'success'> implements LoadFormSuccessResult {
+    constructor(options: FormSuccessResultOptions);
+}

package/dist/entrypoints/FormResult/FormWarningResult.d.ts

@@ -0,0 +1,15 @@
+import { LoadFormWarningResult, LoadFormWarnings } from '../../client/form/LoadFormResult.ts';
+import { BasePrimaryInstanceOptions } from '../../instance/PrimaryInstance.ts';
+import { FormResource } from '../../instance/resource.ts';
+import { ReactiveScope } from '../../lib/reactivity/scope.ts';
+import { BaseInstantiableFormResult } from './BaseInstantiableFormResult.ts';
+export interface FormWarningResultOptions {
+    readonly warnings: LoadFormWarnings;
+    readonly error: null;
+    readonly scope: ReactiveScope;
+    readonly formResource: FormResource;
+    readonly instanceOptions: BasePrimaryInstanceOptions;
+}
+export declare class FormWarningResult extends BaseInstantiableFormResult<'warning'> implements LoadFormWarningResult {
+    constructor(options: FormWarningResultOptions);
+}

package/dist/entrypoints/createInstance.d.ts

@@ -0,0 +1,9 @@
+import { CreatedFormInstance } from '../client/form/CreateFormInstance.ts';
+import { FormInstanceConfig } from '../client/form/FormInstanceConfig.ts';
+import { LoadFormOptions } from '../client/form/LoadForm.ts';
+import { FormResource } from '../instance/resource.ts';
+export interface CreateInstanceOptions {
+    readonly form?: LoadFormOptions;
+    readonly instance?: FormInstanceConfig;
+}
+export declare const createInstance: (formResource: FormResource, options?: CreateInstanceOptions) => Promise<CreatedFormInstance>;

package/dist/entrypoints/editInstance.d.ts

@@ -0,0 +1,9 @@
+import { EditedFormInstance, EditFormInstanceInput } from '../client/form/EditFormInstance.ts';
+import { FormInstanceConfig } from '../client/form/FormInstanceConfig.ts';
+import { LoadFormOptions } from '../client/form/LoadForm.ts';
+import { FormResource } from '../instance/resource.ts';
+export interface EditInstanceOptions {
+    readonly form?: LoadFormOptions;
+    readonly instance?: FormInstanceConfig;
+}
+export declare const editInstance: (formResource: FormResource, input: EditFormInstanceInput, options?: EditInstanceOptions) => Promise<EditedFormInstance>;

package/dist/entrypoints/index.d.ts

@@ -0,0 +1,4 @@
+export * from './createInstance.ts';
+export * from './editInstance.ts';
+export * from './loadForm.ts';
+export * from './restoreInstance.ts';

package/dist/entrypoints/loadForm.d.ts

@@ -0,0 +1,4 @@
+import { FormResource } from '../client/form/FormResource.ts';
+import { LoadFormOptions } from '../client/form/LoadForm.ts';
+import { LoadFormResult } from '../client/form/LoadFormResult.ts';
+export declare const loadForm: (formResource: FormResource, options?: LoadFormOptions) => Promise<LoadFormResult>;

package/dist/entrypoints/restoreInstance.d.ts

@@ -0,0 +1,9 @@
+import { FormInstanceConfig } from '../client/form/FormInstanceConfig.ts';
+import { LoadFormOptions } from '../client/form/LoadForm.ts';
+import { RestoredFormInstance, RestoreFormInstanceInput } from '../client/form/RestoreFormInstance.ts';
+import { FormResource } from '../instance/resource.ts';
+export interface RestoreInstanceOptions {
+    readonly form?: LoadFormOptions;
+    readonly instance?: FormInstanceConfig;
+}
+export declare const restoreInstance: (formResource: FormResource, input: RestoreFormInstanceInput, options?: RestoreInstanceOptions) => Promise<RestoredFormInstance>;

package/dist/error/LoadFormFailureError.d.ts

@@ -0,0 +1,9 @@
+import { FormResource } from '../client/form/FormResource.ts';
+/**
+ * @todo This is a placeholder class, given a name so it can be referenced in
+ * client interfaces for form loading. It is pending design of errors (broadly)
+ * and modeling of form loading errors (specifically).
+ */
+export declare class LoadFormFailureError extends AggregateError {
+    constructor(resource: FormResource, errors: readonly Error[]);
+}

package/dist/error/MalformedInstanceDataError.d.ts

@@ -0,0 +1,3 @@
+import { ErrorProductionDesignPendingError } from './ErrorProductionDesignPendingError.ts';
+export declare class MalformedInstanceDataError extends ErrorProductionDesignPendingError {
+}

package/dist/error/TemplatedNodeAttributeSerializationError.d.ts

@@ -0,0 +1,22 @@
+/**
+ * This error class is intended as a common point of reference for all of the
+ * related interfaces and implementation where we've deferred two concerns:
+ *
+ * 1. Support for attributes on instance nodes (which may be bound in a form's
+ *    model and/or may be expected to preserve model-defined defaults)
+ * 2. Present lack of logic to treat a `jr:template` attribute as a special
+ *    case: whereas in the general case we would expect to pass through a
+ *    form/model-defined attribute, we expect to specifically **omit**
+ *    `jr:template` from repeat instances derived from any of form's
+ *    explicitly-defined repeat templates
+ *
+ * Addressing #1 is (now) a prerequisite to addressing #2, and it is also a
+ * prerequisite for #2's unaddressed status to _become meaningfully observable
+ * and problematic_.
+ *
+ * By introducing this error at a point where a change in #1's status is likely
+ * to be implicated, we're also likely to be reminded to address #2 in tandem.
+ */
+export declare class TemplatedNodeAttributeSerializationError extends Error {
+    constructor();
+}

package/dist/index.d.ts

@@ -1,33 +1,2 @@
-import { InitializeForm } from './index.ts';
-export declare const initializeForm: InitializeForm;
-export type * from './client/constants.ts';
-export * as constants from './client/constants.ts';
-export type * from './client/EngineConfig.ts';
-export type * from './client/FormLanguage.ts';
-export type * from './client/GroupNode.ts';
-export type { AnyChildNode, AnyControlNode, AnyLeafNode, AnyNode, AnyParentNode, AnyUnsupportedControlNode, GeneralChildNode, GeneralParentNode, RepeatRangeNode, } from './client/hierarchy.ts';
-export type * from './client/index.ts';
-export type * from './client/InputNode.ts';
-export type * from './client/ModelValueNode.ts';
-export type * from './client/NoteNode.ts';
-export type * from './client/OpaqueReactiveObjectFactory.ts';
-export type * from './client/RangeNode.ts';
-export type * from './client/repeat/RepeatInstanceNode.ts';
-export type * from './client/repeat/RepeatRangeControlledNode.ts';
-export type * from './client/repeat/RepeatRangeUncontrolledNode.ts';
-export type * from './client/resources.ts';
-export type * from './client/RootNode.ts';
-export type * from './client/SelectNode.ts';
-export type * from './client/submission/SubmissionData.ts';
-export type * from './client/submission/SubmissionDefinition.ts';
-export type * from './client/submission/SubmissionInstanceFile.ts';
-export type * from './client/submission/SubmissionOptions.ts';
-export type * from './client/submission/SubmissionResult.ts';
-export type * from './client/submission/SubmissionState.ts';
-export type * from './client/SubtreeNode.ts';
-export type * from './client/TextRange.ts';
-export type * from './client/TriggerNode.ts';
-export type * from './client/RankNode.ts';
-export type * from './client/unsupported/UploadNode.ts';
-export type * from './client/validation.ts';
-export type * from './client/ValueType.ts';
+export * from './client/index.ts';
+export * from './entrypoints/index.ts';