Struct ActionParam 

pub struct ActionParam {
    pub name: Cow<'static, str>,
    pub ty: ParamType,
    pub required: bool,
    pub entry: bool,
    pub description: Cow<'static, str>,
    pub choices: Vec<Cow<'static, str>>,
    pub schema: Option<Arc<Value>>,
    pub nullable: bool,
}

One typed parameter an action declares.

Fields

name: Cow<'static, str>

ty: ParamType

required: bool

Whether an invocation must supply it. An optional parameter’s default belongs to the action and is stated in description — the surface does not invent one.

entry: bool

Whether one line of typed text fills this parameter, and the others the words it says (title: Text (entry)). An action with one is offered as a capture: a person types “call landlord fri 10am” and the action’s own field types read the rest.

description: Cow<'static, str>

choices: Vec<Cow<'static, str>>

When non-empty, the only values this parameter accepts.

This is what turns a prose list ("grayscale / sepia / invert") into something a caller can read and something ActionArgs::bind can enforce. A value outside the set is refused by name rather than quietly falling through to a default.

schema: Option<Arc<Value>>

JSON Schema fragment applied after the basic type check. This carries ranges, lengths, patterns, formats, item/object schemas, and defaults without growing a second incompatible validation vocabulary.

nullable: bool

Explicitly permits JSON null. Optional means omitted; nullable means present with no value, and callers need to distinguish the two.

Implementations

impl ActionParam

pub const fn required( name: &'static str, ty: ParamType, description: &'static str, ) -> ActionParam

A required parameter with static strings — usable in a const.

pub const fn optional( name: &'static str, ty: ParamType, description: &'static str, ) -> ActionParam

An optional parameter with static strings — usable in a const.

pub fn required_owned( name: impl Into<Cow<'static, str>>, ty: ParamType, description: impl Into<Cow<'static, str>>, ) -> ActionParam

A required parameter whose strings are built at runtime — what an app declaring parameters out of live document state needs.

pub fn optional_owned( name: impl Into<Cow<'static, str>>, ty: ParamType, description: impl Into<Cow<'static, str>>, ) -> ActionParam

An optional parameter whose strings are built at runtime.

pub fn taking_entry(self) -> ActionParam

Have one line of typed text fill this parameter, and the parameters the words say (ActionParam::entry).

pub fn with_choices<S>( self, choices: impl IntoIterator<Item = S>, ) -> ActionParam

where S: Into<Cow<'static, str>>,

Restrict this parameter to choices. Binding refuses anything else.

pub fn with_schema(self, schema: Value) -> ActionParam

pub fn with_shared_schema(self, schema: Arc<Value>) -> ActionParam

Retain an immutable schema already shared by the current type generation. Wire serialization and strict argument validation are unchanged.

pub fn of_resource_kind(self, kind: impl Into<String>) -> ActionParam

Name the kind of resource this ParamType::Resource parameter takes (e.g. files.entry), as the RESOURCE_KIND_ANNOTATION of its schema. Surfaces use it to offer the action on resources of that kind and its sub-kinds.

pub fn with_labelled_choices<V, L>( self, choices: impl IntoIterator<Item = (V, L)>, ) -> ActionParam

where V: Into<Cow<'static, str>>, L: Into<String>,

Restrict this parameter to the first of each pair, each read as the second (CHOICE_LABELS_ANNOTATION): binding still takes only the values, and a surface offers the labels.

pub fn choosing_people<S>( self, people: impl IntoIterator<Item = S>, ) -> ActionParam

where S: Into<String>,

Mark which choices are people (PEOPLE_ANNOTATION): each is shown with the avatar of its label, keyed by its value. Choices not named (a “Create new” beside the identities) read as text alone.

pub fn picking(self, pick: Pick) -> ActionParam

Have a person pick this parameter’s value from the workspace’s picks (PICK_ANNOTATION); callers that know the value still give it as the parameter’s type says. A resource is picked as a reference (resource_reference_schema), whatever schema the parameter had.

pub fn pick(&self) -> Option<Pick>

What this parameter’s value picks from the workspace (Self::picking).

pub fn choice_label(&self, choice: &str) -> Option<&str>

How choice reads to a person (Self::with_labelled_choices).

pub fn resource_kind(&self) -> Option<&str>

The kind of resource this parameter takes, when it is a resource parameter that names one (Self::of_resource_kind).

pub fn as_place(self) -> ActionParam

Make this a place inside the resource the action is on: an object naming one of its items ({"item": id}), a caret in it ({"item": id, "at": n}) or a range of it ({"item": id, "start": n, "end": n}). Marked with the PLACE_ANNOTATION, so a palette or an agent offers the resource’s items rather than free text. An action given one acts there instead of at the invoker’s caret.

pub fn as_place_in(self, field: &str) -> ActionParam

Self::as_place, its items being those of the collection field (a document’s paragraphs, blocks): the item resources published as <resource>/<field>/<item>.

pub fn as_content(self) -> ActionParam

Make this text parameter the address of content another action produced: a caller chains it from that action’s result, never from words (marked with the CONTENT_ANNOTATION).

pub fn as_content_list(self) -> ActionParam

Make this list parameter a list of content addresses, each one content another action produced (Self::as_content), in order.

pub fn is_content_list(&self) -> bool

Whether this parameter takes a list of content (Self::as_content_list).

pub fn is_content(&self) -> bool

Whether this parameter takes content another action produced (Self::as_content).

pub fn is_place(&self) -> bool

Whether this parameter is a place inside the resource (Self::as_place).

pub fn place_field(&self) -> Option<&str>

The collection whose items this place parameter names, when it says (Self::as_place_in).

pub fn nullable(self) -> ActionParam

pub fn validate_declaration(&self) -> Vec<String>

Validate this parameter’s descriptor independently of any supplied value, suitable for an untrusted publication boundary.

Trait Implementations

impl Clone for ActionParam

fn clone(&self) -> ActionParam

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ActionParam

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ActionParam

fn deserialize<__D>( __deserializer: __D, ) -> Result<ActionParam, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Model for ActionParam

const TABLE: &'static ModelTable

The type’s functions as data, which a record holding it reaches it through ([crate::table]): by default its own functions, erased.

type Paths<R> = Path<R, ActionParam>

The typed paths into a value of this type, rooted in the record R: a struct of field paths for a record, the Path itself for a value edited whole or through its own operations.

fn paths_at<R>(path: Path<R, ActionParam>) -> Path<R, ActionParam>

The paths of the value at path.

fn op_coalesces( path: &[Segment], previous: &Value, next: &Value, ) -> Option<bool>

Whether two edits in the own vocabulary of the value at path below this type are one gesture (Operations); None when nothing there has one.

fn op_continuable(path: &[Segment], op: &Value) -> Option<bool>

Whether a gesture may go on after the edit op at path.

fn op_describe(path: &[Segment], op: &Value) -> Option<OpDescription>

What the edit op at path below this type did, in the history entry’s terms (Operations::describe).

fn op_lands(&self, path: &[Segment], op: &Value) -> Option<Place>

Where the actor of the edit op at path below this value is after it applied.

fn op_schemas(prefix: &str, out: &mut Vec<(String, Value)>)

The schemas of the own vocabularies of the values below this type, by path pattern from prefix (* for every item).

fn to_json(&self) -> Value

The value as JSON: what [EditOp::Set] carries and history shows.

fn from_json(value: &Value) -> Result<ActionParam, ModelError>

A value from its Self::to_json form.

fn edit( doc: &mut AutoCommit, slot: Slot<'_>, path: &[Segment], op: &EditOp, cx: &mut ActionCx, ) -> Result<(), ModelError>

Apply the field edit op at path, below the value in slot, touching only what it changes, then run the invariants of the values it touched. The default edits a value only as a whole.

fn check(&self) -> Result<(), Refusal>

Run every #[model(check)] invariant of this value and the values inside it.

fn get_at(&self, path: &[Segment]) -> Option<&(dyn Any + 'static)>

The value at path below this one, if it is there. A value with nothing inside it is found only at the empty path.

fn diff<R>(&self, after: &ActionParam, path: &[Segment], out: &mut Vec<Edit<R>>)

The field edits that turn self into after, at path below the record: what a surface that edited a local copy submits. The default sets the value whole when it changed; containers and records edit only what differs, item by item and field by field. A value that would store as it is (Self::stores_as) is compared in memory, without turning either side into JSON.

fn load( doc: &AutoCommit, value: &Value<'_>, id: &ExId, ) -> Result<ActionParam, ModelError>

Read from the value a parent found in its slot.

fn store(&self, doc: &mut AutoCommit, slot: Slot<'_>) -> Result<(), ModelError>

Write self into slot, changing only what differs from what the slot already holds.

fn stores_as(&self, before: &ActionParam) -> bool

Whether writing self over a slot that holds before, as a store left it, would change nothing: an in-memory comparison, so an action that changed one item of a long collection does not visit the others. Must only answer true when store would write no operation; the default answers false (unknown).

fn store_changed( &self, before: &ActionParam, doc: &mut AutoCommit, slot: Slot<'_>, dirty: &Delta, ) -> Result<(), ModelError>

Write self into slot, which holds before: exactly the operations store would write, found by comparing with before where store would read the document.

fn refresh( &mut self, doc: &AutoCommit, value: &Value<'_>, id: &ExId, delta: &Delta, ) -> Result<(), ModelError>

Bring a value read earlier up to date after the changes in delta, re-reading only what they touched. value and id are what the parent’s slot holds now — the same object as when self was read, or the parent would have read it anew. The default reads the value again, which is right for scalars and short values.

fn collect_text(&self, out: &mut Vec<String>)

Append the human-readable text this value carries, for search indexing.

fn missing() -> Result<ActionParam, ModelError>

The value of an absent slot. Types with a natural empty value return it, so a field added to a schema reads older documents without migration.

const SHAPE: Shape = crate::Shape::Value

How the value is laid out in the document; see Shape. Types written whole keep the default.

const CHECKS: bool = false

Whether this type or any value inside it has a #[model(check)] invariant; Self::check has nothing to do otherwise.

const OPS: bool = false

Whether this type or a value inside it has a vocabulary of its own (Operations, rich text’s): a record routes those edits’ gestures, landing places and schemas only into such fields, and never instantiates the routing for the others.

const NULLABLE: bool = false

Whether null is a value of the type: an absent Option. A field edit setting any other type to null is refused.

const SCALAR: bool = false

Whether store writes one scalar, with nothing inside it that a concurrent writer could add to. A record made just now leaves out such a field holding its missing value: an absent key reads as it. An object (text, a map, a list) is always made with its record, so two writers fill the same one.

fn nested_collections(&self) -> Vec<ItemCollection>

The item collections inside this value, when it is an item of a collection itself (a slide’s elements); #[derive(Model)] lists a record’s, the default has none.

fn value_schema() -> Value

The JSON Schema of this value’s JSON form (Self::to_json), as the published field edit describes what a path takes; the default accepts any value.

fn field_type(types: &mut TypeSet) -> FieldType

This value’s type in the language-neutral vocabulary a surface publishes (FieldType), declaring the records and enums it names in types. The default describes no type: any value.

fn read_whole(&mut self, doc: &AutoCommit) -> Result<(), ModelError>

Read everything this value holds, for a field marked #[model(whole)]: a value read lazily (rich text reads its paragraphs as views ask for them) reads all of it, so every reader of the record — a verb, search, read_content — sees all of it. The default has nothing more to read.

fn label(&self) -> Option<String>

What names this value for people (#[model(label)]): history, search, agents and item resources use it.

impl PartialEq for ActionParam

fn eq(&self, other: &ActionParam) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ActionParam

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ActionParam

impl Settable for ActionParam

impl StructuralPartialEq for ActionParam