@aventara/core 1.0.0-rc.0 → 1.0.0-rc.2

package/dist/contracts/contract.d.ts

@@ -1,22 +1,22 @@
-import type { ContractLimits } from "./contract-limits.js";
-import type { ClientContractProtocol } from "./contract-protocol.js";
-import type { EnumDefinition } from "./enum-definition.js";
+import type { AvContractLimits } from "./contract-limits.js";
+import type { AvContractClientProtocol } from "./contract-protocol.js";
+import type { AvEnumDefinition } from "./enum-definition.js";
 import type { ReferenceWriteLimit } from "./reference-write-limit.js";
-import type { Resource } from "./resource.js";
-import type { ScalarRegistry } from "./scalar.js";
-import type { TransactionCapability } from "./transaction-capability.js";
+import type { AvResource } from "./resource.js";
+import type { AvScalarRegistry } from "./scalar.js";
+import type { AvTransactionCapability } from "./transaction-capability.js";
 /** What every Contract describes: scalars, enums, Resources, limits and transactions. */
-export interface Contract {
+export interface AvContract {
     /** The scalar types available. */
-    readonly scalars: ScalarRegistry;
+    readonly scalars: AvScalarRegistry;
     /** The enums, by name. */
-    readonly enums: Readonly<Record<string, EnumDefinition>>;
+    readonly enums: Readonly<Record<string, AvEnumDefinition>>;
     /** The Resources, by name. */
-    readonly resources: Readonly<Record<string, Resource<this>>>;
+    readonly resources: Readonly<Record<string, AvResource<this>>>;
     /** The request limits in force. */
-    readonly limits: ContractLimits;
+    readonly limits: AvContractLimits;
     /** Whether interactive transactions are available. */
-    readonly transactions: TransactionCapability;
+    readonly transactions: AvTransactionCapability;
     /**
      * `"uniform"` when one record must write the relations that hold a reference
      * either all as relations or all through their reference fields; a record
@@ -25,16 +25,24 @@ export interface Contract {
     readonly referenceWrites?: ReferenceWriteLimit;
 }
 /** The Contract compiled from the root configuration. */
-export interface CoreContract extends Contract {
+export interface AvContractCore extends AvContract {
 }
 /** The Contract in-process calls run under (`framework.application`). */
-export interface ApplicationContract extends Contract {
+export interface AvContractApplication extends AvContract {
 }
 /**
  * The Contract remote clients run under, published at `GET /_contract` and
  * identified by its hash.
  */
-export interface ClientContract extends Contract {
+export interface AvContractClient extends AvContract {
     /** The protocol version and this Contract's hash. */
-    readonly protocol: ClientContractProtocol;
+    readonly protocol: AvContractClientProtocol;
+}
+/**
+ * The Contract an AI agent's calls run under (the `agent` layer), identified by
+ * its hash. MCP tools are built from it.
+ */
+export interface AvContractAgent extends AvContract {
+    /** The protocol version and this Contract's hash. */
+    readonly protocol: AvContractClientProtocol;
 }

package/dist/contracts/create-requirements.d.ts

@@ -0,0 +1,35 @@
+/**
+ * A required to-one relation and the scalar fields that hold its reference,
+ * relation first: `["author", "authorId"]`. A create writes the relation, or
+ * every one of the fields together (`["author", "tenantId", "authorId"]` for a
+ * composite reference), never both.
+ */
+export type AvCreateRequirementGroup = readonly [string, string, ...string[]];
+/**
+ * What a create of one Resource cannot do without, as the Contract's layer
+ * exposes it. Only fields the layer lets a caller write at create appear: a
+ * group whose reference fields the layer hides is its relation alone, in
+ * `required`; one whose relation it hides is its reference fields, in
+ * `required`; a field a compute stage fills at create (`COMPUTED_ON_CREATE`) is
+ * not required.
+ */
+export type AvCreateRequirements = {
+    /**
+     * The fields every create must write: scalars with no default, generated or
+     * computed value, and relations whose reference fields the layer hides.
+     */
+    readonly required?: readonly [string, ...string[]];
+    /** The required relations a create writes either way: see {@link AvCreateRequirementGroup}. */
+    readonly oneOf?: readonly [
+        AvCreateRequirementGroup,
+        ...AvCreateRequirementGroup[]
+    ];
+    /**
+     * By parent Resource, then by its relation: the fields above that a create
+     * nested through that relation gets from its parent, so it is not required
+     * there. `{ "User": { "posts": ["author", "authorId"] } }`: a post created in
+     * `User.posts` needs neither `author` nor `authorId`; a group any of whose
+     * fields is listed is satisfied whole.
+     */
+    readonly parentSupplies?: Readonly<Record<string, Readonly<Record<string, readonly [string, ...string[]]>>>>;
+};

package/dist/contracts/create-requirements.js

@@ -0,0 +1 @@
+export {};

package/dist/contracts/enum-definition.d.ts

@@ -1,5 +1,5 @@
 /** An enum: its allowed values. */
-export type EnumDefinition = {
+export type AvEnumDefinition = {
     /** The allowed values, in declaration order. */
     readonly values: readonly string[];
 };

package/dist/contracts/field-check.d.ts

@@ -0,0 +1,101 @@
+/** The named string formats: what `AvZ.email()`, `AvZ.uuid()` and the rest check. */
+export type AvFieldCheckFormat = "email" | "url" | "emoji" | "uuid" | "guid" | "nanoid" | "cuid" | "cuid2" | "ulid" | "xid" | "ksuid" | "datetime" | "date" | "time" | "duration" | "ipv4" | "ipv6" | "cidrv4" | "cidrv6" | "base64" | "base64url" | "json_string" | "e164" | "credit_card" | "iban" | "jwt";
+/**
+ * A bound on a value (`AvZ.lt`, `AvZ.gte`, `AvZ.positive`, …). `value` is a number
+ * for an `int` or `float` field and a Json number; for a `bigint`, `decimal` or
+ * `datetime` field it is the bound's wire string.
+ */
+export type AvFieldRangeCheck = {
+    readonly check: "less_than" | "greater_than";
+    readonly value: number | string;
+    readonly inclusive: boolean;
+};
+/** `AvZ.multipleOf`: `value` is written as {@link AvFieldRangeCheck}'s is. */
+export type AvFieldMultipleCheck = {
+    readonly check: "multiple_of";
+    readonly value: number | string;
+};
+/** A length bound: a string's, or with `list: true` a list's. */
+export type AvFieldLengthCheck = {
+    readonly check: "max_length";
+    readonly maximum: number;
+    readonly list?: true;
+} | {
+    readonly check: "min_length";
+    readonly minimum: number;
+    readonly list?: true;
+} | {
+    readonly check: "length_equals";
+    readonly length: number;
+};
+/** A pattern or a named format a string must match. */
+export type AvFieldFormatCheck = {
+    readonly check: "string_format";
+    readonly format: "regex";
+    /** A JavaScript regular expression: its `source` and its `flags`. */
+    readonly pattern: {
+        readonly source: string;
+        readonly flags: string;
+    };
+} | {
+    readonly check: "string_format";
+    readonly format: "includes";
+    readonly includes: string;
+} | {
+    readonly check: "string_format";
+    readonly format: "starts_with";
+    readonly prefix: string;
+} | {
+    readonly check: "string_format";
+    readonly format: "ends_with";
+    readonly suffix: string;
+} | {
+    readonly check: "string_format";
+    readonly format: "lowercase" | "uppercase" | AvFieldCheckFormat;
+};
+/** A `bytes` value's byte length. */
+export type AvFieldSizeCheck = {
+    readonly check: "max_size";
+    readonly maximum: number;
+} | {
+    readonly check: "min_size";
+    readonly minimum: number;
+} | {
+    readonly check: "size_equals";
+    readonly size: number;
+};
+/**
+ * One field validator as the Contract stores it: its check's name (`check`) and
+ * the check's parameters.
+ */
+export type AvFieldCheck = AvFieldRangeCheck | AvFieldMultipleCheck | AvFieldLengthCheck | AvFieldFormatCheck | AvFieldSizeCheck;
+/** The checks a Json Shape's string node may carry: its length, a pattern or a format. */
+export type AvJsonStringCheck = {
+    readonly check: "max_length";
+    readonly maximum: number;
+} | {
+    readonly check: "min_length";
+    readonly minimum: number;
+} | {
+    readonly check: "length_equals";
+    readonly length: number;
+} | AvFieldFormatCheck;
+/** The checks a Json Shape's number or integer node may carry: bounds are numbers. */
+export type AvJsonNumberCheck = {
+    readonly check: "less_than" | "greater_than";
+    readonly value: number;
+    readonly inclusive: boolean;
+} | {
+    readonly check: "multiple_of";
+    readonly value: number;
+};
+/** The checks a Json Shape's array node may carry: its length. */
+export type AvJsonListCheck = {
+    readonly check: "max_length";
+    readonly maximum: number;
+    readonly list: true;
+} | {
+    readonly check: "min_length";
+    readonly minimum: number;
+    readonly list: true;
+};

package/dist/contracts/field-check.js

@@ -0,0 +1 @@
+export {};

package/dist/contracts/field.d.ts

@@ -1,72 +1,89 @@
-import type { PaginationCapability, ProjectionScope, RelationFilterCapability, RelationMutationDirective, RelationReducer, ScalarFilterOperator, ScalarMutationDirective, WriteScope } from "./capability.js";
-import type { Contract } from "./contract.js";
+import type { AvPaginationCapability, AvProjectionScope, AvRelationFilterCapability, AvRelationMutationDirective, AvRelationReducer, AvScalarFilterOperator, AvScalarMutationDirective, AvWriteScope, ScalarFilterMode } from "./capability.js";
+import type { AvContract } from "./contract.js";
+import type { AvFieldCheck } from "./field-check.js";
 import type { JsonSchema } from "./json-shape.js";
-import type { LifecycleTrait } from "./lifecycle-trait.js";
+import type { AvLifecycleTrait } from "./lifecycle-trait.js";
 /** A format name that refines a scalar type, carried in the Contract as data. */
-export type ScalarFormat = string;
+export type AvScalarFormat = string;
 /** The projection positions a field can be selected in (at least one). */
-export type ProjectionScopes = readonly [ProjectionScope, ...ProjectionScope[]];
+export type AvProjectionScopes = readonly [
+    AvProjectionScope,
+    ...AvProjectionScope[]
+];
 /**
  * The write positions a field can be written in (at least one). A scope list
- * applies to the top level of a write argument only; see {@link WriteScope}.
+ * applies to the top level of a write argument only; see {@link AvWriteScope}.
  */
-export type WriteScopes = readonly [WriteScope, ...WriteScope[]];
+export type AvWriteScopes = readonly [AvWriteScope, ...AvWriteScope[]];
 /**
  * Whether a relation can be selected or included: `true`, or the projection
  * positions it can be used in.
  */
-export type RelationProjectionCapability = boolean | ProjectionScopes;
+export type AvRelationProjectionCapability = boolean | AvProjectionScopes;
 /**
  * The reducers a relation admits, qualified by the projection positions they are
  * admitted in. The reducer list and the scope list are separate facts: `$count` is
  * one of a closed set of reducers, and the scopes say where the reducer may be
  * asked for.
  */
-export type ScopedRelationReducers = {
-    readonly reducers: readonly RelationReducer[];
-    readonly scopes: ProjectionScopes;
+export type AvScopedRelationReducers = {
+    readonly reducers: readonly AvRelationReducer[];
+    readonly scopes: AvProjectionScopes;
 };
 /**
  * A relation's reducers: a reducer list, or an object with the reducers and
  * the projection positions they apply in.
  */
-export type RelationReducerCapability = readonly RelationReducer[] | ScopedRelationReducers;
+export type AvRelationReducerCapability = readonly AvRelationReducer[] | AvScopedRelationReducers;
 /**
  * The mutation directives a relation admits at one write stage, and the write
  * positions they are admitted in. `directives: []` means writable with no
  * directive.
  */
-export type ScopedRelationMutations = {
-    readonly directives: readonly RelationMutationDirective[];
-    readonly scopes: WriteScopes;
+export type AvScopedRelationMutations = {
+    readonly directives: readonly AvRelationMutationDirective[];
+    readonly scopes: AvWriteScopes;
 };
 /**
  * A relation's write capability for `create` or `update`: a directive list, or
  * an object with the directives and the write positions they apply in.
  */
-export type RelationMutationCapability = readonly RelationMutationDirective[] | ScopedRelationMutations;
+export type AvRelationMutationCapability = readonly AvRelationMutationDirective[] | AvScopedRelationMutations;
 /** What can be done with a scalar field. Scalar capabilities apply in every position. */
-export type ScalarFieldCapabilities = {
+export type AvScalarFieldCapabilities = {
     readonly select?: boolean;
-    readonly filter?: readonly ScalarFilterOperator[];
+    readonly filter?: readonly AvScalarFilterOperator[];
+    /**
+     * The modes the `mode` operator takes on this field: `"default"` (the
+     * database's own comparison) always, and `"sensitive"` or `"insensitive"`
+     * where the adapter honours them. Present exactly when `filter` offers `mode`.
+     */
+    readonly filterModes?: readonly ScalarFilterMode[];
+    /**
+     * A `json` field's modes when the filter names a `path`: the text compared is
+     * the value at that path rather than the whole document, and the database may
+     * honour more modes there. Present exactly when `filter` offers `mode` and
+     * `path`; without a `path`, `filterModes` applies.
+     */
+    readonly pathFilterModes?: readonly ScalarFilterMode[];
     readonly order?: boolean;
     readonly orderNulls?: boolean;
-    readonly create?: readonly ScalarMutationDirective[];
-    readonly update?: readonly ScalarMutationDirective[];
+    readonly create?: readonly AvScalarMutationDirective[];
+    readonly update?: readonly AvScalarMutationDirective[];
 };
 /** What can be done with a relation field. */
-export type RelationFieldCapabilities = {
-    readonly select?: RelationProjectionCapability;
-    readonly include?: RelationProjectionCapability;
-    readonly filter?: readonly RelationFilterCapability[];
+export type AvRelationFieldCapabilities = {
+    readonly select?: AvRelationProjectionCapability;
+    readonly include?: AvRelationProjectionCapability;
+    readonly filter?: readonly AvRelationFilterCapability[];
     readonly order?: boolean;
-    readonly pagination?: readonly PaginationCapability[];
-    readonly reducers?: RelationReducerCapability;
-    readonly create?: RelationMutationCapability;
-    readonly update?: RelationMutationCapability;
+    readonly pagination?: readonly AvPaginationCapability[];
+    readonly reducers?: AvRelationReducerCapability;
+    readonly create?: AvRelationMutationCapability;
+    readonly update?: AvRelationMutationCapability;
     /**
      * What the `where` of a nested `$update` or `$delete` through this relation may
-     * filter: `"scalar"` — the target's scalar fields only, combined with
+     * filter: `"scalar"` means the target's scalar fields only, combined with
      * `AND`/`OR`/`NOT`, and no relation filter at any depth. Absent: any filter the
      * target takes.
      */
@@ -76,53 +93,75 @@ export type RelationFieldCapabilities = {
  * The reducers a relation advertises, in any projection position. Use
  * {@link advertisedReducersAt} for one position.
  */
-export declare function advertisedReducers(capability: RelationReducerCapability | undefined): readonly RelationReducer[] | undefined;
+export declare function advertisedReducers(capability: AvRelationReducerCapability | undefined): readonly AvRelationReducer[] | undefined;
 /** Whether a projection capability holds at one projection position. */
-export declare function holdsAt(capability: RelationProjectionCapability | undefined, scope: ProjectionScope): boolean;
+export declare function holdsAt(capability: AvRelationProjectionCapability | undefined, scope: AvProjectionScope): boolean;
 /**
  * Whether a projection capability holds in **any** projection position. Use
  * {@link holdsAt} when the position is known.
  */
-export declare function holdsInAnyScope(capability: RelationProjectionCapability | undefined): boolean;
+export declare function holdsInAnyScope(capability: AvRelationProjectionCapability | undefined): boolean;
 /**
  * The reducers a relation advertises at one projection position, or
  * `undefined` where it has none there.
  */
-export declare function advertisedReducersAt(capability: RelationReducerCapability | undefined, scope: ProjectionScope): readonly RelationReducer[] | undefined;
+export declare function advertisedReducersAt(capability: AvRelationReducerCapability | undefined, scope: AvProjectionScope): readonly AvRelationReducer[] | undefined;
 /**
  * The mutation directives a relation advertises at one write stage, in any
  * write position. `undefined` means the stage is unavailable; `[]` means
  * available with no directive.
  */
-export declare function advertisedDirectives(capability: RelationMutationCapability | undefined): readonly RelationMutationDirective[] | undefined;
+export declare function advertisedDirectives(capability: AvRelationMutationCapability | undefined): readonly AvRelationMutationDirective[] | undefined;
 /**
  * The mutation directives a relation advertises at one write position, or
  * `undefined` where it is not writable there.
  */
-export declare function advertisedDirectivesAt(capability: RelationMutationCapability | undefined, scope: WriteScope): readonly RelationMutationDirective[] | undefined;
+export declare function advertisedDirectivesAt(capability: AvRelationMutationCapability | undefined, scope: AvWriteScope): readonly AvRelationMutationDirective[] | undefined;
 /** A scalar field, including an enum-backed one. */
-export type ScalarField<C extends Contract> = {
+export type AvScalarField<C extends AvContract> = {
     readonly kind: "scalar";
     readonly type: {
         readonly scalar: Extract<keyof C["scalars"], string>;
     } | {
         readonly enum: Extract<keyof C["enums"], string>;
     };
-    readonly format?: ScalarFormat;
+    readonly format?: AvScalarFormat;
     readonly nullable: boolean;
     readonly list: boolean;
-    readonly lifecycle: readonly LifecycleTrait[];
-    readonly capabilities: ScalarFieldCapabilities;
+    readonly lifecycle: readonly AvLifecycleTrait[];
+    readonly capabilities: AvScalarFieldCapabilities;
     /** A `json` field's shape, as JSON Schema: what every value written to it is. */
     readonly json?: JsonSchema;
+    /**
+     * The field's validators: the root's checks, then the overlay's, in
+     * registration order. On a list field a check applies to each entry, except a
+     * `list: true` length check, which applies to the list.
+     */
+    readonly validators?: readonly AvFieldCheck[];
 };
 /** A relation field; the `target` Resource describes the related row. */
-export type RelationField<C extends Contract> = {
+export type AvRelationField<C extends AvContract> = {
     readonly kind: "relation";
     readonly target: Extract<keyof C["resources"], string>;
     readonly cardinality: "one" | "many";
     readonly nullable: boolean;
-    readonly capabilities: RelationFieldCapabilities;
+    readonly capabilities: AvRelationFieldCapabilities;
+    /**
+     * The target's relation field that is this relation's other end
+     * (`User.posts` ↔ `Post.author`): a record written through this relation sits
+     * at that field's `"loopback"` write position. Absent when the adapter states
+     * no pairing or the layer hides the other end.
+     */
+    readonly inverse?: string;
+    /**
+     * The scalar fields of this Resource that hold the relation's reference, in the
+     * order the data source pairs them with the target's key (`Post.category` has
+     * `["categoryId"]`). Writing the relation and one of them in one record names
+     * the reference twice; inside a record written through the relation's other
+     * end they sit at the `"loopback"` position with it. Absent on the end that
+     * holds no reference, and where the layer shows none of them.
+     */
+    readonly referenceFields?: readonly [string, ...string[]];
 };
 /** One field of a Resource: a scalar or a relation. */
-export type Field<C extends Contract> = ScalarField<C> | RelationField<C>;
+export type AvField<C extends AvContract> = AvScalarField<C> | AvRelationField<C>;

package/dist/contracts/identifier.d.ts

@@ -1,7 +1,7 @@
-import type { Contract } from "./contract.js";
-import type { Field } from "./field.js";
+import type { AvContract } from "./contract.js";
+import type { AvField } from "./field.js";
 /** Keys of `TFields` whose field can be scalar-shaped. */
-export type ScalarFieldKey<TFields extends Readonly<Record<string, Field<Contract>>>> = Extract<{
+export type AvScalarFieldKey<TFields extends Readonly<Record<string, AvField<AvContract>>>> = Extract<{
     [K in keyof TFields]: [
         Extract<TFields[K], {
             readonly kind: "scalar";
@@ -9,4 +9,4 @@ export type ScalarFieldKey<TFields extends Readonly<Record<string, Field<Contrac
     ] extends [never] ? never : K;
 }[keyof TFields], string>;
 /** Non-empty tuple of scalar field keys that identifies at most one Resource. */
-export type Identifier<TFields extends Readonly<Record<string, Field<Contract>>>> = readonly [ScalarFieldKey<TFields>, ...ScalarFieldKey<TFields>[]];
+export type AvIdentifier<TFields extends Readonly<Record<string, AvField<AvContract>>>> = readonly [AvScalarFieldKey<TFields>, ...AvScalarFieldKey<TFields>[]];

package/dist/contracts/json-shape.d.ts

@@ -1,3 +1,4 @@
+import type { AvJsonListCheck, AvJsonNumberCheck, AvJsonStringCheck } from "./field-check.js";
 /**
  * The phantom key a Json Shape's TypeScript type travels under. Type-level only:
  * no value ever holds it.
@@ -20,7 +21,15 @@ export type JsonSchemaPrimitive = string | number | boolean | null;
  * the forms Aventara emits.
  */
 export type JsonSchema = {
-    readonly type: "string" | "number" | "integer" | "boolean" | "null";
+    readonly type: "boolean" | "null";
+} | {
+    readonly type: "string";
+    /** The node's checks, in the order they were added. */
+    readonly checks?: readonly AvJsonStringCheck[];
+} | {
+    readonly type: "number" | "integer";
+    /** The node's checks, in the order they were added. */
+    readonly checks?: readonly AvJsonNumberCheck[];
 } | {
     readonly const: JsonSchemaPrimitive;
 } | {
@@ -39,6 +48,8 @@ export type JsonSchema = {
 } | {
     readonly type: "array";
     readonly items: JsonSchema;
+    /** The list's length checks, in the order they were added. */
+    readonly checks?: readonly AvJsonListCheck[];
 } | {
     readonly type: "array";
     readonly prefixItems: readonly [JsonSchema, ...JsonSchema[]];

package/dist/contracts/lifecycle-trait.d.ts

@@ -1,8 +1,8 @@
 /**
  * Where a field's value comes from, without saying whether it is writable:
  * `DEFAULTED` and `GENERATED_ON_*` by the data source, `COMPUTED_ON_*` by a
- * framework behavior; `VIRTUAL` marks a field that is not stored.
+ * compute stage; `VIRTUAL` marks a field that is not stored.
  */
 export declare const LIFECYCLE_TRAITS: readonly ["DEFAULTED", "GENERATED_ON_CREATE", "GENERATED_ON_UPDATE", "COMPUTED_ON_CREATE", "COMPUTED_ON_UPDATE", "COMPUTED_ON_READ", "VIRTUAL"];
 /** One of {@link LIFECYCLE_TRAITS}. */
-export type LifecycleTrait = (typeof LIFECYCLE_TRAITS)[number];
+export type AvLifecycleTrait = (typeof LIFECYCLE_TRAITS)[number];

package/dist/contracts/resource-operations.d.ts

@@ -1,62 +1,62 @@
-import type { ProjectionScope, WriteScope } from "./capability.js";
+import type { AvProjectionScope, AvWriteScope } from "./capability.js";
 /**
  * The argument scopes one advertised operation variant qualifies its arguments
  * with: which projection position its projection arguments sit in, and which write
  * position its data argument sits in.
  */
-export type OperationVariantScopes = {
-    readonly projection: ProjectionScope;
-    readonly write?: WriteScope;
+export type AvOperationVariantScopes = {
+    readonly projection: AvProjectionScope;
+    readonly write?: AvWriteScope;
 } | {
-    readonly projection?: ProjectionScope;
-    readonly write: WriteScope;
+    readonly projection?: AvProjectionScope;
+    readonly write: AvWriteScope;
 };
 /**
  * Availability of one standard operation variant: `true` for "available, with no
  * scope qualification stated", or the scopes the variant qualifies its arguments
  * with.
  */
-export type OperationAvailability = true | OperationVariantScopes;
+export type AvOperationAvailability = true | AvOperationVariantScopes;
 /** Availability of protocol-defined standard operations for one Resource. */
-export type ResourceOperations = {
+export type AvResourceOperations = {
     readonly find?: {
-        readonly first?: OperationAvailability;
-        readonly unique?: OperationAvailability;
-        readonly many?: OperationAvailability;
-        readonly count?: OperationAvailability;
+        readonly first?: AvOperationAvailability;
+        readonly unique?: AvOperationAvailability;
+        readonly many?: AvOperationAvailability;
+        readonly count?: AvOperationAvailability;
     };
     readonly create?: {
-        readonly one?: OperationAvailability;
-        readonly many?: OperationAvailability;
-        readonly count?: OperationAvailability;
+        readonly one?: AvOperationAvailability;
+        readonly many?: AvOperationAvailability;
+        readonly count?: AvOperationAvailability;
     };
     readonly update?: {
-        readonly first?: OperationAvailability;
-        readonly unique?: OperationAvailability;
-        readonly many?: OperationAvailability;
-        readonly count?: OperationAvailability;
+        readonly first?: AvOperationAvailability;
+        readonly unique?: AvOperationAvailability;
+        readonly many?: AvOperationAvailability;
+        readonly count?: AvOperationAvailability;
     };
     readonly delete?: {
-        readonly first?: OperationAvailability;
-        readonly unique?: OperationAvailability;
-        readonly many?: OperationAvailability;
-        readonly count?: OperationAvailability;
+        readonly first?: AvOperationAvailability;
+        readonly unique?: AvOperationAvailability;
+        readonly many?: AvOperationAvailability;
+        readonly count?: AvOperationAvailability;
     };
     readonly upsert?: {
-        readonly unique?: OperationAvailability;
+        readonly unique?: AvOperationAvailability;
     };
 };
 /**
- * Whether one `ResourceOperations` entry marks its variant available: it is
+ * Whether one `AvResourceOperations` entry marks its variant available: it is
  * `true` or an argument-position descriptor.
  */
-export declare function isOperationVariantAvailable(availability: unknown): availability is OperationAvailability;
+export declare function isOperationVariantAvailable(availability: unknown): availability is AvOperationAvailability;
 /**
  * The projection position one advertised variant's projection arguments sit in.
  */
-export declare function projectionScopeOf(availability: unknown): ProjectionScope;
+export declare function projectionScopeOf(availability: unknown): AvProjectionScope;
 /**
  * The write position one advertised variant's data argument sits in, and the write
  * mirror of {@link projectionScopeOf}.
  */
-export declare function writeScopeOf(availability: unknown): WriteScope;
+export declare function writeScopeOf(availability: unknown): AvWriteScope;

package/dist/contracts/resource.d.ts

@@ -1,12 +1,18 @@
-import type { Contract } from "./contract.js";
-import type { Field } from "./field.js";
-import type { Identifier } from "./identifier.js";
-import type { ResourceOperations } from "./resource-operations.js";
+import type { AvContract } from "./contract.js";
+import type { AvCreateRequirements } from "./create-requirements.js";
+import type { AvField } from "./field.js";
+import type { AvIdentifier } from "./identifier.js";
+import type { AvResourceOperations } from "./resource-operations.js";
 /** A Resource's fields, by name. */
-export type ResourceFieldMap<C extends Contract> = Readonly<Record<string, Field<C>>>;
-/** One Resource: its fields, identifiers and available operations. */
-export type Resource<C extends Contract, TFields extends ResourceFieldMap<C> = ResourceFieldMap<C>> = {
+export type AvResourceFieldMap<C extends AvContract> = Readonly<Record<string, AvField<C>>>;
+/**
+ * One Resource: its fields, identifiers and available operations, and what a
+ * create of it cannot do without.
+ */
+export type AvResource<C extends AvContract, TFields extends AvResourceFieldMap<C> = AvResourceFieldMap<C>> = {
     readonly fields: TFields;
-    readonly identifiers: readonly Identifier<TFields>[];
-    readonly operations: ResourceOperations;
+    readonly identifiers: readonly AvIdentifier<TFields>[];
+    readonly operations: AvResourceOperations;
+    /** What a create must write; absent when it requires nothing. */
+    readonly createRequirements?: AvCreateRequirements;
 };