@getodk/xforms-engine 0.4.0 → 0.6.0

package/src/client/RootNode.ts

@@ -3,14 +3,18 @@ import type { RootDefinition } from '../parse/model/RootDefinition.ts';
 import type { BaseNode, BaseNodeState } from './BaseNode.ts';
 import type { ActiveLanguage, FormLanguage, FormLanguages } from './FormLanguage.ts';
 import type { GeneralChildNode } from './hierarchy.ts';
+import type { SubmissionOptions } from './submission/SubmissionOptions.ts';
+import type {
+	ChunkedSubmissionResult,
+	MonolithicSubmissionResult,
+	SubmissionResult,
+} from './submission/SubmissionResult.ts';
 import type { AncestorNodeValidationState } from './validation.ts';
 
 export interface RootNodeState extends BaseNodeState {
 	/**
-	 * This, along with {@link RootNode.languages} is the most significant break
-	   in consistency across node types' state and static properties. Exposing it
-	   across all node types seems like a point of potential confusion, so this
-	   particular divergence seems like the most reasonable compromise.
+	 * @todo If we ever expose an interface to the primary instance document, it
+	 * would make sense to move this state up.
 	 */
 	get activeLanguage(): ActiveLanguage;
 
@@ -29,6 +33,8 @@ export interface RootNode extends BaseNode {
 	 */
 	readonly appearances: null;
 
+	readonly nodeOptions: null;
+
 	/**
 	 * @todo This is another odd deviation in {@link RootNode}. Unlike
 	 * {@link languages}, it doesn't feel particularly **essential**. While it
@@ -46,15 +52,45 @@ export interface RootNode extends BaseNode {
 
 	readonly definition: RootDefinition;
 	readonly root: RootNode;
-	readonly parent: null;
+	readonly parent: unknown;
 	readonly currentState: RootNodeState;
 	readonly validationState: AncestorNodeValidationState;
 
 	/**
-	 * @todo as with {@link RootNodeState.activeLanguage}, this is the most
-	 * significant break in consistency across node types.
+	 * @todo as discussed on {@link RootNodeState.activeLanguage}
 	 */
 	readonly languages: FormLanguages;
 
 	setLanguage(language: FormLanguage): RootNode;
+
+	/**
+	 * Prepares the current form instance state for submission.
+	 *
+	 * A {@link SubmissionResult} will be prepared even if the current form state
+	 * includes `constraint` or `required` violations. This is intended to serve
+	 * two purposes:
+	 *
+	 * - A client may effectively use this method as a part of its own "submit"
+	 *   routine, and use any violations included in the {@link SubmissionResult}
+	 *   to prompt users to address those violations.
+	 *
+	 * - A client may inspect the submission state of a form at any time.
+	 *   Depending on the client and use case, this may be a convenience (e.g. for
+	 *   developers to inspect that form state at a current point in time); or it
+	 *   may provide necessary functionality (e.g. for test or tooling clients).
+	 *
+	 * Note on asynchrony: preparing a {@link SubmissionResult} is expected to be
+	 * a fast operation. It may even be nearly instantaneous, or roughly
+	 * proportionate to the size of the form itself. However, this method is
+	 * designed to be asynchronous out of an abundance of caution, anticipating
+	 * that some as-yet undeveloped operations on binary data (e.g. form
+	 * attachments) may themselves impose asynchrony (i.e. by interfaces provided
+	 * by the platform and/or external dependencies).
+	 *
+	 * A client may specify {@link SubmissionOptions<'chunked'>}, in which case a
+	 * {@link SubmissionResult<'chunked'>} will be produced, with form attachments
+	 */
+	prepareSubmission(): Promise<MonolithicSubmissionResult>;
+	prepareSubmission(options: SubmissionOptions<'monolithic'>): Promise<MonolithicSubmissionResult>;
+	prepareSubmission(options: SubmissionOptions<'chunked'>): Promise<ChunkedSubmissionResult>;
 }

package/src/client/SelectNode.ts

@@ -1,24 +1,26 @@
-import type { AnySelectDefinition } from '../parse/body/control/select/SelectDefinition.ts';
+import type {
+	AnySelectControlDefinition,
+	SelectType,
+} from '../parse/body/control/SelectControlDefinition.ts';
 import type { LeafNodeDefinition } from '../parse/model/LeafNodeDefinition.ts';
-import type { BaseNode, BaseNodeState } from './BaseNode.ts';
+import type { BaseValueNode, BaseValueNodeState } from './BaseValueNode.ts';
 import type { NodeAppearances } from './NodeAppearances.ts';
 import type { RootNode } from './RootNode.ts';
-import type { StringNode } from './StringNode.ts';
 import type { TextRange } from './TextRange.ts';
+import type { ValueType } from './ValueType.ts';
 import type { GeneralParentNode } from './hierarchy.ts';
 import type { LeafNodeValidationState } from './validation.ts';
 
 export interface SelectItem {
+	get label(): TextRange<'item-label'>;
 	get value(): string;
-	get label(): TextRange<'item-label'> | null;
 }
 
-export interface SelectNodeState extends BaseNodeState {
+export type SelectValueOptions = readonly SelectItem[];
+
+export interface SelectNodeState extends BaseValueNodeState<readonly string[]> {
 	get children(): null;
 
-	/**
-	 * @todo should {@link BaseNodeState} include this??
-	 */
 	get valueOptions(): readonly SelectItem[];
 
 	/**
@@ -33,43 +35,68 @@ export interface SelectNodeState extends BaseNodeState {
 	 * Should a `SelectNodeState` have this `value` type, whereas a hypothetical
 	 * `Select1NodeState` would have `get value(): SelectItem | null`?
 	 */
-	get value(): readonly SelectItem[];
+	get value(): readonly string[];
 }
 
-export interface SelectDefinition extends LeafNodeDefinition {
-	readonly bodyElement: AnySelectDefinition;
+export interface SelectDefinition<V extends ValueType = ValueType> extends LeafNodeDefinition<V> {
+	readonly bodyElement: AnySelectControlDefinition;
 }
 
 export type SelectNodeAppearances = NodeAppearances<SelectDefinition>;
 
-export interface SelectNode extends BaseNode {
+export interface SelectNode extends BaseValueNode<'string', readonly string[]> {
 	readonly nodeType: 'select';
+	readonly valueType: 'string';
+	readonly selectType: SelectType;
 	readonly appearances: SelectNodeAppearances;
-	readonly definition: SelectDefinition;
+	readonly nodeOptions: null;
+	readonly definition: SelectDefinition<'string'>;
 	readonly root: RootNode;
 	readonly parent: GeneralParentNode;
 	readonly currentState: SelectNodeState;
 	readonly validationState: LeafNodeValidationState;
 
 	/**
-	 * For use by a client to update the selection of a select node where:
+	 * Convenience API to get the {@link SelectItem} which is associated with
+	 * {@link value}, if one is currently available—i.e. if it is present in
+	 * {@link SelectNodeState.valueOptions}.
+	 */
+	getValueOption(value: string): SelectItem | null;
+
+	/**
+	 * Convenience API to determine if {@link value} is currently selected—i.e. if
+	 * it is one of the selected values in {@link SelectNodeState.value}.
+	 */
+	isSelected(value: string): boolean;
+
+	/**
+	 * Selects a single {@link value}, as provided by a {@link SelectItem.value}.
+	 * Calling this setter replaces the currently selected value(s, if any),
+	 * where:
 	 *
-	 * - For fields defined with an XForms `<select>`, calling this method is
-	 *   additive, i.e. it will include the item in its
-	 *   {@link SelectNodeState.value}.
-	 * - For fields defined with an XForms `<select1>`, calling this method will
-	 *   replace the selection (if any).
+	 * - if the provided value is `null`, the current selection is cleared; ELSE
+	 * - the provided value is selected in place of any currently selected values.
 	 *
-	 * @todo @see {@link StringNode.setValue} re: write restrictions
-	 * @todo @see {@link SelectNodeState.value} re: breaking up the types
+	 * This setter is most useful for {@link SelectNode}s associated with an
+	 * XForms
+	 * {@link https://getodk.github.io/xforms-spec/#body-elements | `<select1>`}
+	 * control.
 	 */
-	select(item: SelectItem): RootNode;
+	selectValue(value: string | null): RootNode;
 
 	/**
-	 * For use by a client to remove an item from the node's
-	 * {@link SelectNodeState.value}.
+	 * Selects any number of {@link values}, as provided by any number of
+	 * {@link SelectItem.value}s. Calling this setter replaces the currently
+	 * selected value(s, if any). If called with an empty array, the current
+	 * selection is cleared.
+	 *
+	 * This setter is most useful for {@link SelectNode}s associated with an
+	 * XForms
+	 * {@link https://getodk.github.io/xforms-spec/#body-elements | `<select>`}
+	 * control.
 	 *
-	 * @todo @see {@link StringNode.setValue} re: write restrictions
+	 * This setter _may_ be used with a `<select1>` control, in which case the
+	 * provided {@link values} should produce at most one value.
 	 */
-	deselect(item: SelectItem): RootNode;
+	selectValues(values: readonly string[]): RootNode;
 }

package/src/client/SubtreeNode.ts

@@ -52,6 +52,7 @@ export interface SubtreeDefinition extends BaseSubtreeDefinition {
 export interface SubtreeNode extends BaseNode {
 	readonly nodeType: 'subtree';
 	readonly appearances: null;
+	readonly nodeOptions: null;
 	readonly definition: SubtreeDefinition;
 	readonly root: RootNode;
 	readonly parent: GeneralParentNode;

package/src/client/TriggerNode.ts

@@ -1,25 +1,31 @@
+import type { TriggerRuntimeValue, TriggerValueType } from '../lib/codecs/TriggerCodec.ts';
 import type { UnknownAppearanceDefinition } from '../parse/body/appearance/unknownAppearanceParser.ts';
 import type { TriggerControlDefinition } from '../parse/body/control/TriggerControlDefinition.ts';
 import type { LeafNodeDefinition } from '../parse/model/LeafNodeDefinition.ts';
-import type { BaseNode, BaseNodeState } from './BaseNode.ts';
+import type { BaseValueNode, BaseValueNodeState } from './BaseValueNode.ts';
 import type { GeneralParentNode } from './hierarchy.ts';
 import type { RootNode } from './RootNode.ts';
 import type { LeafNodeValidationState } from './validation.ts';
+import type { ValueType } from './ValueType.ts';
 
-export interface TriggerNodeState extends BaseNodeState {
+export type TriggerValue = TriggerRuntimeValue;
+
+export interface TriggerNodeState extends BaseValueNodeState<TriggerValue> {
 	get children(): null;
 	get valueOptions(): null;
-	get value(): boolean;
+	get value(): TriggerValue;
 }
 
-export interface TriggerNodeDefinition extends LeafNodeDefinition {
+export interface TriggerNodeDefinition<V extends ValueType = ValueType>
+	extends LeafNodeDefinition<V> {
 	readonly bodyElement: TriggerControlDefinition;
 }
 
-export interface TriggerNode extends BaseNode {
+export interface TriggerNode extends BaseValueNode<TriggerValueType, TriggerValue> {
 	readonly nodeType: 'trigger';
-	readonly definition: TriggerNodeDefinition;
+	readonly definition: TriggerNodeDefinition<TriggerValueType>;
 	readonly appearances: UnknownAppearanceDefinition;
+	readonly nodeOptions: null;
 	readonly root: RootNode;
 	readonly parent: GeneralParentNode;
 	readonly currentState: TriggerNodeState;

package/src/client/ValueType.ts

@@ -0,0 +1,4 @@
+import type { ExpandUnion } from '@getodk/common/types/helpers.js';
+import type { BindType } from '../parse/model/BindTypeDefinition.ts';
+
+export type ValueType = ExpandUnion<BindType>;

package/src/client/constants.ts

@@ -1,5 +1,66 @@
+import type { PrimaryInstance } from '../instance/PrimaryInstance.ts';
+import type { InitializeForm } from './index.ts';
 import type { ValidationTextRole } from './TextRange.ts';
 
+export const MISSING_RESOURCE_BEHAVIOR = {
+	/**
+	 * When this behavior is configured, {@link InitializeForm | initializing} a
+	 * {@link PrimaryInstance} for a form which references any **missing**
+	 * resources will fail, producing an error to the calling client.
+	 *
+	 * @see {@link MissingResourceBehavior}
+	 */
+	ERROR: 'ERROR',
+
+	/**
+	 * When this behavior is configured, {@link InitializeForm | initializing} a
+	 * {@link PrimaryInstance} for a form which references any **missing**
+	 * resources will succeed (producing a warning).
+	 *
+	 * Such missing resources will be parsed as if they are blank, as appropriate
+	 * for the resource's XForm semantic usage and/or format.
+	 *
+	 * @see {@link MissingResourceBehavior}
+	 */
+	BLANK: 'BLANK',
+
+	/**
+	 * @see {@link MISSING_RESOURCE_BEHAVIOR.ERROR}
+	 */
+	get DEFAULT(): 'ERROR' {
+		return MISSING_RESOURCE_BEHAVIOR.ERROR;
+	},
+} as const;
+
+export type MissingResourceBehaviorError = typeof MISSING_RESOURCE_BEHAVIOR.ERROR;
+
+export type MissingResourceBehaviorBlank = typeof MISSING_RESOURCE_BEHAVIOR.BLANK;
+
+export type MissingResourceBehaviorDefault = typeof MISSING_RESOURCE_BEHAVIOR.DEFAULT;
+
+/**
+ * Specifies behavior for {@link InitializeForm | initializing} a form's
+ * {@link PrimaryInstance} which references any **missing** resources.
+ *
+ * Here the term "missing" is consistent with
+ * {@link https://www.rfc-editor.org/rfc/rfc9110#status.404 | HTTP 404 status}
+ * semantics. Clients which provide access to form attachments by performing
+ * HTTP network requests (e.g. with {@link fetch}) can generally convey this
+ * semantic meaning with a standard {@link Response}.
+ *
+ * **IMPORTANT**
+ *
+ * The term "missing" is distinct from other network/IO failures, e.g. when
+ * network access itself is unavailable. In these cases, the engine will
+ * consider a resource's availability **ambiguous**, producing an error
+ * regardless of the configured behavior for **missing** resources.
+ */
+// prettier-ignore
+export type MissingResourceBehavior =
+	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
+	| MissingResourceBehaviorError
+	| MissingResourceBehaviorBlank;
+
 export const VALIDATION_TEXT = {
 	constraintMsg: 'Condition not satisfied: constraint',
 	requiredMsg: 'Condition not satisfied: required',
@@ -8,3 +69,9 @@ export const VALIDATION_TEXT = {
 type ValidationTextDefaults = typeof VALIDATION_TEXT;
 
 export type ValidationTextDefault<Role extends ValidationTextRole> = ValidationTextDefaults[Role];
+
+export const SUBMISSION_INSTANCE_FILE_NAME = 'xml_submission_file';
+export type SubmissionInstanceFileName = typeof SUBMISSION_INSTANCE_FILE_NAME;
+
+export const SUBMISSION_INSTANCE_FILE_TYPE = 'text/xml';
+export type SubmissionInstanceFileType = typeof SUBMISSION_INSTANCE_FILE_TYPE;

package/src/client/hierarchy.ts

@@ -1,37 +1,36 @@
 import type { ExpandUnion } from '@getodk/common/types/helpers.d.ts';
 import type { GroupNode } from './GroupNode.ts';
-import type { ModelValueNode } from './ModelValueNode.ts';
-import type { NoteNode } from './NoteNode.ts';
+import type { AnyInputNode } from './InputNode.ts';
+import type { AnyModelValueNode } from './ModelValueNode.ts';
+import type { AnyNoteNode } from './NoteNode.ts';
+import type { AnyRangeNode } from './RangeNode.ts';
 import type { RepeatInstanceNode } from './repeat/RepeatInstanceNode.ts';
 import type { RepeatRangeControlledNode } from './repeat/RepeatRangeControlledNode.ts';
 import type { RepeatRangeUncontrolledNode } from './repeat/RepeatRangeUncontrolledNode.ts';
 import type { RootNode } from './RootNode.ts';
 import type { SelectNode } from './SelectNode.ts';
-import type { StringNode } from './StringNode.ts';
 import type { SubtreeNode } from './SubtreeNode.ts';
 import type { TriggerNode } from './TriggerNode.ts';
-import type { RangeNode } from './unsupported/RangeNode.ts';
-import type { RankNode } from './unsupported/RankNode.ts';
+import type { RankNode } from './RankNode.ts';
 import type { UploadNode } from './unsupported/UploadNode.ts';
 
 // prettier-ignore
-export type AnyUnsupportedControlNode =
-	| RangeNode
-	| RankNode
-	| UploadNode;
+export type AnyUnsupportedControlNode = UploadNode;
 
 // prettier-ignore
 export type AnyControlNode =
-	| NoteNode
+	| AnyInputNode
+	| AnyNoteNode
+	| AnyRangeNode
+	| RankNode
 	| SelectNode
-	| StringNode
 	| TriggerNode;
 
 // prettier-ignore
 export type AnyLeafNode =
 	| AnyControlNode
-	| AnyUnsupportedControlNode
-	| ModelValueNode;
+	| AnyModelValueNode
+	| AnyUnsupportedControlNode;
 
 // prettier-ignore
 export type RepeatRangeNode =

package/src/client/identity.ts

@@ -0,0 +1,16 @@
+type ODKXFormsUUID = `uuid:${string}`;
+
+/**
+ * @see {@link https://getodk.github.io/xforms-spec/#metadata}
+ */
+export type InstanceID = ODKXFormsUUID;
+
+/**
+ * @see {@link https://getodk.github.io/xforms-spec/#metadata}
+ */
+export type DeprecatedID = ODKXFormsUUID;
+
+/**
+ * Represents a session-stable identifier for any particular node i
+ */
+export type FormNodeID = `node:${string}`;

package/src/client/node-types.ts

@@ -1,13 +1,23 @@
 // prettier-ignore
 export type UnsupportedControlNodeType =
-	| 'range'
 	| 'rank'
 	| 'upload';
 
 // prettier-ignore
 export type RepeatRangeNodeType =
 	| 'repeat-range:controlled'
-	| 'repeat-range:uncontrolled'
+	| 'repeat-range:uncontrolled';
+
+// prettier-ignore
+export type LeafNodeType =
+	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
+	| 'model-value'
+	| 'note'
+	| 'select'
+	| 'input'
+	| 'trigger'
+	| 'range'
+	| UnsupportedControlNodeType;
 
 // prettier-ignore
 export type InstanceNodeType =
@@ -17,9 +27,5 @@ export type InstanceNodeType =
 	| 'repeat-instance'
 	| 'group'
 	| 'subtree'
-	| 'model-value'
-	| 'note'
-	| 'select'
-	| 'string'
-	| 'trigger'
+	| LeafNodeType
 	| UnsupportedControlNodeType;

package/src/client/resources.ts

@@ -0,0 +1,118 @@
+import type { JRResourceURL } from '@getodk/common/jr-resources/JRResourceURL.ts';
+import type { initializeForm } from '../instance/index.ts';
+
+interface FetchResourceHeadersIterator<T>
+	extends IteratorObject<
+		T,
+		// Note: we use this weird TypeScript intrinsic type so a built-in
+		// `HeadersIterator` is assignable regardless of a client's configured
+		// TypeScript or linting strictness. We don't actually care about the type, or
+		// consume the value it represents.
+		BuiltinIteratorReturn,
+		unknown
+	> {
+	[Symbol.iterator](): FetchResourceHeadersIterator<T>;
+}
+
+type FetchResourceHeadersForEachCallbackFn = (
+	value: string,
+	key: string,
+	parent: FetchResourceResponseHeaders
+) => void;
+
+/**
+ * A read-only strict subset of the web standard {@link Headers}.
+ *
+ * Note that the engine may make the following assumptions about
+ * {@link FetchResourceResponse.headers}:
+ *
+ * - If {@link FetchResourceResponse} is an instance of {@link Response}, it
+ *   will be assumed its {@link FetchResourceResponse.headers | headers object}
+ *   _is present_, and that it is an instance of {@link Headers}. In other
+ *   words: for the purposes of resource resolution, we explicitly expect that
+ *   clients using APIs provided by the runtime platform (or polyfills thereof)
+ *   will not monkey-patch properties of values produced by those APIs.
+ *
+ * - If the object is an instance of {@link Headers} (whether by inference as a
+ *   property of {@link Response}, or by a direct instance type check), the
+ *   engine will assume it is safe to treat header names as case insensitive for
+ *   any lookups it may perform. In other words: we explicitly expect that
+ *   clients _providing access_ to APIs rovided by the runtime platform (or
+ *   polyfills thereof) will not alter the guarantees of those APIs.
+ *
+ * - If the object is not an instance of {@link Headers}, it will be treated as
+ *   a {@link ReadonlyMap<string, string>}. In other words: we explicitly expect
+ *   that clients, when providing a bespoke implementation of
+ *   {@link FetchResourceResponse} and its constituent parts, will likely
+ *   implement them partially (and in the case of
+ *   {@link FetchResourceResponse.headers}, with the nearest common idiom
+ *   available). In this case, we will favor a best effort at correctness,
+ *   generally at some expense of performance.
+ */
+export interface FetchResourceResponseHeaders {
+	[Symbol.iterator](): FetchResourceHeadersIterator<[string, string]>;
+
+	entries(): FetchResourceHeadersIterator<[string, string]>;
+	keys(): FetchResourceHeadersIterator<string>;
+	values(): FetchResourceHeadersIterator<string>;
+
+	get(name: string): string | null;
+	has(name: string): boolean;
+	forEach(callbackfn: FetchResourceHeadersForEachCallbackFn): void;
+}
+
+/**
+ * This is a strict subset of the web standard {@link Response}. Clients are
+ * encouraged to use the global {@link Response} constructor (as provided by the
+ * runtime platform, or by a global runtime polyfill), but may also provide a
+ * bespoke implementation if it suits their needs.
+ *
+ * Since we cannot assume a client's implementation will always be an instance
+ * of {@link Response}, we make some assumptions about its {@link headers}
+ * object (if available, as detailed on {@link FetchResourceResponseHeaders}).
+ *
+ * For other properties, we make the following assumptions (all of which are
+ * assumptions we would make about a platform-provided/polyfilled
+ * {@link Response}, but are explicitly stated for the benefit of confidence in
+ * client implementations):
+ *
+ * - If we read {@link body} directly, we will assume it is consumed on first
+ *   read, and will not read it again.
+ *
+ * - We assume that {@link blob} and {@link text} indirectly consume
+ *   {@link body} on first read as well, and will only ever read one of each of
+ *   these properties, and only ever once.
+ *
+ * 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
+ * {@link Promise<PrimaryInstance>} returned by that call is resolved.
+ */
+export interface FetchResourceResponse {
+	readonly ok?: boolean;
+	readonly status?: number;
+	readonly body?: ReadableStream<Uint8Array> | null;
+	readonly bodyUsed?: boolean;
+	readonly headers?: FetchResourceResponseHeaders;
+
+	readonly blob: () => Promise<Blob>;
+	readonly text: () => Promise<string>;
+}
+
+/**
+ * This is a strict subset of the web standard `fetch` interface. It implicitly
+ * assumes that the engine itself will only ever perform `GET`-like network/IO
+ * requests. It also provides no further request-like semantics to the engine.
+ *
+ * This is presumed sufficient for now, but notably doesn't expose any notion of
+ * content negotiation (e.g. the ability for the engine to include `Accept`
+ * headers in resource requests issued to a client's {@link FetchResource}
+ * implementation).
+ */
+export type FetchResource<Resource extends URL = URL> = (
+	resource: Resource
+) => Promise<FetchResourceResponse>;
+
+export type FormAttachmentURL = JRResourceURL;
+
+export type FetchFormAttachment = FetchResource<FormAttachmentURL>;

package/src/client/submission/SubmissionData.ts

@@ -0,0 +1,12 @@
+import type {
+	SubmissionInstanceFile,
+	SubmissionInstanceFileName,
+} from './SubmissionInstanceFile.ts';
+
+export interface SubmissionData extends FormData {
+	get(name: SubmissionInstanceFileName): SubmissionInstanceFile;
+	get(name: string): FormDataEntryValue | null;
+
+	has(name: SubmissionInstanceFileName): true;
+	has(name: string): boolean;
+}

package/src/client/submission/SubmissionDefinition.ts

@@ -0,0 +1,16 @@
+export interface SubmissionDefinition {
+	/**
+	 * @see {@link https://getodk.github.io/xforms-spec/#submission-attributes | `action` submission attribute}
+	 */
+	readonly submissionAction: URL | null;
+
+	/**
+	 * @see {@link https://getodk.github.io/xforms-spec/#submission-attributes | `method` submission attribute}
+	 */
+	readonly submissionMethod: 'post';
+
+	/**
+	 * @see {@link https://getodk.github.io/xforms-spec/#submission-attributes | `base64RsaPublicKey` submission attribute}
+	 */
+	readonly encryptionKey: string | null;
+}

package/src/client/submission/SubmissionInstanceFile.ts

@@ -0,0 +1,9 @@
+import type { SubmissionInstanceFileName, SubmissionInstanceFileType } from '../constants.ts';
+
+// Re-export for convenient `SubmissionInstanceFile` construction/access flows
+export type { SubmissionInstanceFileName, SubmissionInstanceFileType };
+
+export interface SubmissionInstanceFile extends File {
+	readonly name: SubmissionInstanceFileName;
+	readonly type: SubmissionInstanceFileType;
+}

package/src/client/submission/SubmissionOptions.ts

@@ -0,0 +1,28 @@
+export type SubmissionChunkedType = 'chunked' | 'monolithic';
+
+interface BaseSubmissionOptions<ChunkedType extends SubmissionChunkedType> {
+	readonly chunked?: ChunkedType | 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 ChunkedSubmissionOptions extends BaseSubmissionOptions<'chunked'> {
+	readonly maxSize: number;
+}
+
+interface MonolithicSubmissionOptions extends BaseSubmissionOptions<'monolithic'> {
+	readonly chunked?: 'monolithic' | undefined;
+	readonly maxSize?: never;
+}
+
+// prettier-ignore
+export type SubmissionOptions<ChunkedType extends SubmissionChunkedType = 'monolithic'> = {
+	chunked: ChunkedSubmissionOptions;
+	monolithic: MonolithicSubmissionOptions;
+}[ChunkedType];