@api-client/core 0.18.57 → 0.18.59

package/data/models/example-generator-api.json

@@ -42062,10 +42062,10 @@
 "@id": "#209"
 },
 {
-"@id": "#194"
+"@id": "#191"
 },
 {
-"@id": "#191"
+"@id": "#194"
 },
 {
 "@id": "#197"
@@ -43436,7 +43436,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "addressType: 'REGISTERED-OFFICE-ADDRESS'\nstreetName: 'UITBREIDINGSTRAAT'\nhouseNumber: '84'\nhouseNumberAddition: '/1'\npostalCode: '2600'\ncity: 'BERCHEM (ANTWERPEN)'\ncountry: 'Belgium'\ncountryCode: 'BE'\nfullFormatedAddress: \"UITBREIDINGSTRAAT 84 /1, 2600 BERCHEM (ANTWERPEN), BELIUM\"\n",
+"doc:raw": "countryCode: \"BE\"\ngraydonEnterpriseId: 1057155523\nregistrationId: \"0422319093\"\nvatNumber: \"BE0422319093\"\ngraydonCompanyId: \"0422319093\"\nisBranchOffice: false\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -43457,7 +43457,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "countryCode: \"BE\"\ngraydonEnterpriseId: 1057155523\nregistrationId: \"0422319093\"\nvatNumber: \"BE0422319093\"\ngraydonCompanyId: \"0422319093\"\nisBranchOffice: false\n",
+"doc:raw": "addressType: 'REGISTERED-OFFICE-ADDRESS'\nstreetName: 'UITBREIDINGSTRAAT'\nhouseNumber: '84'\nhouseNumberAddition: '/1'\npostalCode: '2600'\ncity: 'BERCHEM (ANTWERPEN)'\ncountry: 'Belgium'\ncountryCode: 'BE'\nfullFormatedAddress: \"UITBREIDINGSTRAAT 84 /1, 2600 BERCHEM (ANTWERPEN), BELIUM\"\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -44756,12 +44756,12 @@
 {
 "@id": "#193/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#193",
-"sourcemaps:value": "[(1,0)-(10,0)]"
+"sourcemaps:value": "[(1,0)-(7,0)]"
 },
 {
 "@id": "#196/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#196",
-"sourcemaps:value": "[(1,0)-(7,0)]"
+"sourcemaps:value": "[(1,0)-(10,0)]"
 },
 {
 "@id": "#199/source-map/lexical/element_0",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@api-client/core",
   "description": "The API Client's core client library. Works in NodeJS and in a ES enabled browser.",
-  "version": "0.18.57",
+  "version": "0.18.59",
   "license": "Apache-2.0",
   "exports": {
     "./browser.js": {

package/src/decorators/observed.ts

@@ -1,6 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 const reactiveSymbol = Symbol('reactive')
 const proxySymbol = Symbol('proxy')
+const rawSymbol = Symbol('raw')
 
 interface DomainInstance {
   domain?: { notifyChange(): void }
@@ -38,6 +39,13 @@ export interface ObserveConfig {
  * @returns The not proxied object or undefined
  */
 export function toRaw<T extends object = object>(source: object, target: T): T | undefined {
+  if (target && (target as any)[rawSymbol]) {
+    let raw = (target as any)[rawSymbol]
+    while (raw && (raw as any)[rawSymbol]) {
+      raw = (raw as any)[rawSymbol]
+    }
+    return raw as T
+  }
   const proxies = Reflect.get(source, proxySymbol) as Map<object, object>
   if (!proxies) {
     return undefined
@@ -101,7 +109,7 @@ export function observed(config: ObserveConfig = {}): PropertyDecorator {
       }
 
       if (proxies.has(obj)) {
-        return obj
+        return proxies.get(obj)
       }
 
       // eslint-disable-next-line @typescript-eslint/no-this-alias
@@ -109,6 +117,12 @@ export function observed(config: ObserveConfig = {}): PropertyDecorator {
 
       const proxy = new Proxy(obj, {
         get(target, prop) {
+          if (prop === proxySymbol) {
+            return Reflect.get(target, prop)
+          }
+          if (prop === rawSymbol) {
+            return target
+          }
           const value = Reflect.get(target, prop)
           return createDeepProxy.bind(targetObject)(value, notifyChange)
         },

package/src/modeling/ApiModel.ts

@@ -2,12 +2,10 @@ import { nanoid } from '../nanoid.js'
 import { ApiModelKind, DataDomainKind, ExposedEntityKind } from '../models/kinds.js'
 import { type IThing, Thing } from '../models/Thing.js'
 import type {
-  AccessRule,
   AssociationTarget,
   AuthenticationConfiguration,
   AuthorizationConfiguration,
   ExposedEntitySchema,
-  RateLimitingConfiguration,
   RolesBasedAccessControl,
   SessionConfiguration,
   UsernamePasswordConfiguration,
@@ -19,6 +17,8 @@ import { observed, toRaw } from '../decorators/observed.js'
 import pluralize from '@jarrodek/pluralize'
 import { createDomainKey } from './helpers/keying.js'
 import { ExposedEntity } from './ExposedEntity.js'
+import { AccessRule, AccessRuleSchema } from './rules/AccessRule.js'
+import { RateLimitingConfiguration, RateLimitingConfigurationSchema } from './rules/RateLimitingConfiguration.js'
 
 /**
  * Contact information for the exposed API.
@@ -106,12 +106,12 @@ export interface ApiModelSchema extends DependentModelSchema {
    * These rules apply to all exposed entities and actions. An API action
    * can declare its own access rules, which will override these.
    */
-  accessRule?: AccessRule[]
+  accessRule?: AccessRuleSchema[]
   /**
    * Optional configuration for API-wide rate limiting and throttling.
    * Defines rules to protect the API from overuse.
    */
-  rateLimiting?: RateLimitingConfiguration
+  rateLimiting?: RateLimitingConfigurationSchema
   /**
    * A URL to the Terms of Service for the API.
    */
@@ -179,12 +179,12 @@ export class ApiModel extends DependentModel {
    * These rules apply to all exposed entities and actions. An API action
    * can declare its own access rules, which will override these.
    */
-  accessRule?: AccessRule[]
+  @observed({ deep: true }) accessor accessRule: AccessRule[]
   /**
    * Optional configuration for API-wide rate limiting and throttling.
    * Defines rules to protect the API from overuse.
    */
-  rateLimiting?: RateLimitingConfiguration
+  @observed() accessor rateLimiting: RateLimitingConfiguration | undefined
   /**
    * A URL to the Terms of Service for the API.
    */
@@ -238,25 +238,25 @@ export class ApiModel extends DependentModel {
       exposes,
     }
     if (input.user) {
-      result.user = { ...input.user }
+      result.user = structuredClone(input.user)
     }
     if (input.dependencyList) {
       result.dependencyList = structuredClone(input.dependencyList)
     }
     if (input.authentication) {
-      result.authentication = input.authentication
+      result.authentication = structuredClone(input.authentication)
     }
     if (input.authorization) {
-      result.authorization = input.authorization
+      result.authorization = structuredClone(input.authorization)
     }
     if (input.session) {
-      result.session = input.session
+      result.session = structuredClone(input.session)
     }
-    if (input.accessRule) {
-      result.accessRule = input.accessRule
+    if (Array.isArray(input.accessRule)) {
+      result.accessRule = structuredClone(input.accessRule)
     }
     if (input.rateLimiting) {
-      result.rateLimiting = input.rateLimiting
+      result.rateLimiting = structuredClone(input.rateLimiting)
     }
     if (input.termsOfService) {
       result.termsOfService = input.termsOfService
@@ -309,11 +309,13 @@ export class ApiModel extends DependentModel {
     } else {
       this.exposes = []
     }
-    if (init.accessRule) {
-      this.accessRule = structuredClone(init.accessRule)
+    if (Array.isArray(init.accessRule)) {
+      this.accessRule = init.accessRule.map((rule) => new AccessRule(rule))
+    } else {
+      this.accessRule = []
     }
     if (init.rateLimiting) {
-      this.rateLimiting = structuredClone(init.rateLimiting)
+      this.rateLimiting = new RateLimitingConfiguration(init.rateLimiting)
     }
     if (init.termsOfService) {
       this.termsOfService = init.termsOfService
@@ -352,11 +354,11 @@ export class ApiModel extends DependentModel {
     if (this.session) {
       result.session = structuredClone(this.session)
     }
-    if (this.accessRule) {
-      result.accessRule = structuredClone(this.accessRule)
+    if (Array.isArray(this.accessRule) && this.accessRule.length > 0) {
+      result.accessRule = this.accessRule.map((rule) => rule.toJSON())
     }
     if (this.rateLimiting) {
-      result.rateLimiting = structuredClone(this.rateLimiting)
+      result.rateLimiting = this.rateLimiting.toJSON()
     }
     if (this.termsOfService) {
       result.termsOfService = this.termsOfService

package/src/modeling/ExposedEntity.ts

@@ -1,17 +1,12 @@
 import { observed } from '../decorators/observed.js'
 import { ExposedEntityKind } from '../models/kinds.js'
 import { nanoid } from '../nanoid.js'
+import { Action } from './actions/Action.js'
 import type { ApiModel } from './ApiModel.js'
 import { ensureLeadingSlash, joinPaths } from './helpers/endpointHelpers.js'
-import type {
-  AccessRule,
-  ApiAction,
-  AssociationTarget,
-  ExposeOptions,
-  ExposeParentRef,
-  RateLimitingConfiguration,
-  ExposedEntitySchema,
-} from './types.js'
+import { AccessRule } from './rules/AccessRule.js'
+import { RateLimitingConfiguration } from './rules/RateLimitingConfiguration.js'
+import type { AssociationTarget, ExposeOptions, ExposeParentRef, ExposedEntitySchema } from './types.js'
 
 /**
  * A class that specializes in representing an exposed Data Entity within an API Model.
@@ -91,7 +86,7 @@ export class ExposedEntity extends EventTarget {
   /**
    * The list of enabled API actions for this exposure (List/Read/Create/etc.)
    */
-  @observed({ deep: true }) accessor actions: ApiAction[]
+  @observed({ deep: true }) accessor actions: Action[]
 
   /**
    * Optional array of access rules that define the access control policies for this exposure.
@@ -162,7 +157,7 @@ export class ExposedEntity extends EventTarget {
     if (exposeOptions !== undefined) {
       result.exposeOptions = { ...exposeOptions }
     }
-    if (accessRule !== undefined) {
+    if (Array.isArray(accessRule)) {
       result.accessRule = accessRule.map((ar) => ({ ...ar }))
     }
     if (rateLimiting !== undefined) {
@@ -187,9 +182,9 @@ export class ExposedEntity extends EventTarget {
     this.isRoot = init.isRoot
     this.parent = init.parent
     this.exposeOptions = init.exposeOptions
-    this.actions = init.actions
-    this.accessRule = init.accessRule
-    this.rateLimiting = init.rateLimiting
+    this.actions = init.actions ? init.actions.map((a) => new Action(a)) : []
+    this.accessRule = init.accessRule ? init.accessRule.map((ar) => new AccessRule(ar)) : []
+    this.rateLimiting = init.rateLimiting ? new RateLimitingConfiguration(init.rateLimiting) : undefined
     this.truncated = init.truncated
     this.#initializing = false
   }
@@ -212,7 +207,7 @@ export class ExposedEntity extends EventTarget {
       key: this.key,
       entity: { ...this.entity },
       resourcePath: this.resourcePath,
-      actions: this.actions.map((a) => ({ ...a })),
+      actions: this.actions.map((a) => a.toJSON()),
       hasCollection: this.hasCollection,
     }
     if (this.collectionPath !== undefined) {
@@ -227,11 +222,11 @@ export class ExposedEntity extends EventTarget {
     if (this.exposeOptions !== undefined) {
       result.exposeOptions = { ...this.exposeOptions }
     }
-    if (this.accessRule !== undefined) {
-      result.accessRule = this.accessRule.map((ar) => ({ ...ar }))
+    if (Array.isArray(this.accessRule) && this.accessRule.length > 0) {
+      result.accessRule = this.accessRule.map((ar) => ar.toJSON())
     }
     if (this.rateLimiting !== undefined) {
-      result.rateLimiting = { ...this.rateLimiting }
+      result.rateLimiting = this.rateLimiting.toJSON()
     }
     if (this.truncated !== undefined) {
       result.truncated = this.truncated

package/src/modeling/actions/Action.ts

@@ -0,0 +1,64 @@
+import { AccessRule, AccessRuleSchema } from '../rules/AccessRule.js'
+import { RateLimitingConfiguration, RateLimitingConfigurationSchema } from '../rules/RateLimitingConfiguration.js'
+import { observed } from '../../decorators/observed.js'
+
+/**
+ * A base interface for common properties across all actions.
+ */
+export interface ActionSchema {
+  /**
+   * The specific kind of action (e.g., 'List', 'Read', etc.)
+   */
+  kind: string
+  /**
+   * Access control rules defining who can perform this action. It is only applied if the
+   * authorization strategy is set to 'RBAC'.
+   * If no rules grant access, it's denied by default making it essentially private.
+   *
+   * Note, the API can defined top level access rules that apply to all actions. If this property is set,
+   * it overrides the top level access rules for this specific action.
+   *
+   * It is an ordered list, meaning the first rule that matches the user will be applied.
+   * If multiple rules match, the first one in the list takes precedence.
+   * If no rules match, the action is denied.
+   */
+  accessRule?: AccessRuleSchema[]
+  /**
+   * Optional configuration for action-wide rate limiting and throttling.
+   * Defines rules to protect the action from overuse.
+   */
+  rateLimiting?: RateLimitingConfigurationSchema
+}
+
+/**
+ * A base class for common properties across all actions.
+ */
+export class Action extends EventTarget implements ActionSchema {
+  @observed() accessor kind: string
+  @observed({ deep: true }) accessor accessRule: AccessRule[]
+  @observed({ deep: true }) accessor rateLimiting: RateLimitingConfiguration | undefined
+
+  constructor(state: Partial<ActionSchema> = {}) {
+    super()
+    this.kind = state.kind || ''
+    this.accessRule = state.accessRule ? state.accessRule.map((rule) => new AccessRule(rule)) : []
+    this.rateLimiting = state.rateLimiting ? new RateLimitingConfiguration(state.rateLimiting) : undefined
+  }
+
+  notifyChange() {
+    this.dispatchEvent(new Event('change'))
+  }
+
+  toJSON(): ActionSchema {
+    const result: ActionSchema = {
+      kind: this.kind,
+    }
+    if (this.accessRule.length) {
+      result.accessRule = this.accessRule.map((rule) => rule.toJSON())
+    }
+    if (this.rateLimiting) {
+      result.rateLimiting = this.rateLimiting.toJSON()
+    }
+    return result
+  }
+}

package/src/modeling/actions/CreateAction.ts

@@ -0,0 +1,38 @@
+import { Action, type ActionSchema } from './Action.js'
+import { observed } from '../../decorators/observed.js'
+
+/**
+ * Enables adding a new resource to a collection.
+ * Endpoint: POST /[entity-collection-name]
+ */
+export interface CreateActionSchema extends ActionSchema {
+  kind: 'create'
+}
+
+/**
+ * Enables adding a new resource to a collection.
+ * Endpoint: POST /[entity-collection-name]
+ */
+export class CreateAction extends Action implements CreateActionSchema {
+  @observed() override accessor kind: 'create'
+
+  constructor(state: Partial<CreateActionSchema> = {}) {
+    super(state)
+    this.kind = 'create'
+  }
+
+  override toJSON(): CreateActionSchema {
+    return {
+      ...(super.toJSON() as CreateActionSchema),
+      kind: 'create',
+    }
+  }
+
+  static isCreateAction(action: Action): action is CreateAction {
+    return action.kind === 'create'
+  }
+
+  static isCreateActionSchema(schema: ActionSchema): schema is CreateActionSchema {
+    return schema.kind === 'create'
+  }
+}

package/src/modeling/actions/DeleteAction.ts

@@ -0,0 +1,59 @@
+import { Action, type ActionSchema } from './Action.js'
+import { observed } from '../../decorators/observed.js'
+
+export type DeleteStrategy = 'soft' | 'hard'
+
+/**
+ * Enables removing an existing resource.
+ * Endpoint: DELETE /[entity-collection-name]/{id}
+ */
+export interface DeleteActionSchema extends ActionSchema {
+  kind: 'delete'
+  /**
+   * The strategy for deletion. Default: Soft Delete.
+   *
+   * @default 'soft'
+   */
+  strategy?: DeleteStrategy
+  /**
+   * The data retention period (in days) for soft-deleted resources.
+   * This defines how long the data should be kept before it is permanently deleted.
+   *
+   * @default 30
+   */
+  retentionPeriod?: number
+}
+
+/**
+ * Enables removing an existing resource.
+ * Endpoint: DELETE /[entity-collection-name]/{id}
+ */
+export class DeleteAction extends Action implements DeleteActionSchema {
+  @observed() override accessor kind: 'delete'
+  @observed() accessor strategy: DeleteStrategy
+  @observed() accessor retentionPeriod: number
+
+  constructor(state: Partial<DeleteActionSchema> = {}) {
+    super(state)
+    this.kind = 'delete'
+    this.strategy = state.strategy || 'soft'
+    this.retentionPeriod = state.retentionPeriod ?? 30
+  }
+
+  override toJSON(): DeleteActionSchema {
+    return {
+      ...(super.toJSON() as DeleteActionSchema),
+      kind: 'delete',
+      strategy: this.strategy,
+      retentionPeriod: this.retentionPeriod,
+    }
+  }
+
+  static isDeleteAction(action: Action): action is DeleteAction {
+    return action.kind === 'delete'
+  }
+
+  static isDeleteActionSchema(schema: ActionSchema): schema is DeleteActionSchema {
+    return schema.kind === 'delete'
+  }
+}

package/src/modeling/actions/ListAction.ts

@@ -0,0 +1,66 @@
+import type { PaginationStrategy } from '../types.js'
+import { Action, type ActionSchema } from './Action.js'
+import { observed, toRaw } from '../../decorators/observed.js'
+
+/**
+ * Enables retrieving a collection of resources.
+ * Endpoint: GET /[entity-collection-name]
+ */
+export interface ListActionSchema extends ActionSchema {
+  kind: 'list'
+  /**
+   * The pagination strategy used for this action.
+   * This defines how the results are paginated when retrieving a collection of resources.
+   * It can be either 'cursor' or 'offset'.
+   */
+  pagination: PaginationStrategy
+  /**
+   * Fields from the entity that can be used for filtering.
+   * Must be marked as "indexable" in the Data Model.
+   */
+  filterableFields: string[]
+  /**
+   * Fields from the entity that can be used for sorting.
+   */
+  sortableFields: string[]
+}
+
+/**
+ * Enables retrieving a collection of resources.
+ * Endpoint: GET /[entity-collection-name]
+ */
+export class ListAction extends Action implements ListActionSchema {
+  @observed() override accessor kind: 'list'
+  @observed({ deep: true }) accessor pagination: PaginationStrategy
+  @observed({ deep: true }) accessor filterableFields: string[] = []
+  @observed({ deep: true }) accessor sortableFields: string[] = []
+
+  constructor(state: Partial<ListActionSchema> = {}) {
+    super(state)
+    this.kind = state.kind || 'list'
+    this.pagination = state.pagination
+      ? { ...state.pagination }
+      : {
+          kind: 'offset',
+        }
+    this.filterableFields = state.filterableFields ? [...state.filterableFields] : []
+    this.sortableFields = state.sortableFields ? [...state.sortableFields] : []
+  }
+
+  override toJSON(): ListActionSchema {
+    return {
+      ...(super.toJSON() as ListActionSchema),
+      pagination: structuredClone(toRaw(this, this.pagination)) as PaginationStrategy,
+      filterableFields: structuredClone(toRaw(this, this.filterableFields)) as string[],
+      sortableFields: structuredClone(toRaw(this, this.sortableFields)) as string[],
+    }
+  }
+
+  static isListAction(action: Action): action is ListAction {
+    return action.kind === 'list'
+  }
+
+  static isListActionSchema(schema: ActionSchema): schema is ListActionSchema {
+    return schema.kind === 'list'
+  }
+}

package/src/modeling/actions/ReadAction.ts

@@ -0,0 +1,40 @@
+import { Action, type ActionSchema } from './Action.js'
+import { observed } from '../../decorators/observed.js'
+
+/**
+ * Enables retrieving a single resource by its ID.
+ * Endpoint: GET /[entity-collection-name]/{id}
+ */
+export interface ReadActionSchema extends ActionSchema {
+  kind: 'read'
+  // Association handling (Link IDs vs. Embed) is defined on the
+  // data association itself in the Data Modeler.
+}
+
+/**
+ * Enables retrieving a single resource by its ID.
+ * Endpoint: GET /[entity-collection-name]/{id}
+ */
+export class ReadAction extends Action implements ReadActionSchema {
+  @observed() override accessor kind: 'read'
+
+  constructor(state: Partial<ReadActionSchema> = {}) {
+    super(state)
+    this.kind = 'read'
+  }
+
+  override toJSON(): ReadActionSchema {
+    return {
+      ...(super.toJSON() as ReadActionSchema),
+      kind: 'read',
+    }
+  }
+
+  static isReadAction(action: Action): action is ReadAction {
+    return action.kind === 'read'
+  }
+
+  static isReadActionSchema(schema: ActionSchema): schema is ReadActionSchema {
+    return schema.kind === 'read'
+  }
+}

package/src/modeling/actions/SearchAction.ts

@@ -0,0 +1,46 @@
+import { Action, type ActionSchema } from './Action.js'
+import { observed, toRaw } from '../../decorators/observed.js'
+
+/**
+ * Enables keyword-based search across specified fields.
+ * Endpoint: GET /[entity-collection-name]/search
+ */
+export interface SearchActionSchema extends ActionSchema {
+  kind: 'search'
+  /**
+   * The fields within the entity to be included in the search scope.
+   * Must be "indexable" and typically text-based.
+   */
+  fields: string[]
+}
+
+/**
+ * Enables keyword-based search across specified fields.
+ * Endpoint: GET /[entity-collection-name]/search
+ */
+export class SearchAction extends Action implements SearchActionSchema {
+  @observed() override accessor kind: 'search'
+  @observed({ deep: true }) accessor fields: string[]
+
+  constructor(state: Partial<SearchActionSchema> = {}) {
+    super(state)
+    this.kind = 'search'
+    this.fields = state.fields ? [...state.fields] : []
+  }
+
+  override toJSON(): SearchActionSchema {
+    return {
+      ...(super.toJSON() as SearchActionSchema),
+      kind: 'search',
+      fields: structuredClone(toRaw(this, this.fields)) as string[],
+    }
+  }
+
+  static isSearchActionSchema(schema: ActionSchema): schema is SearchActionSchema {
+    return schema.kind === 'search'
+  }
+
+  static isSearchAction(action: Action): action is SearchAction {
+    return action.kind === 'search'
+  }
+}

package/src/modeling/actions/UpdateAction.ts

@@ -0,0 +1,49 @@
+import { Action, type ActionSchema } from './Action.js'
+import { observed, toRaw } from '../../decorators/observed.js'
+
+/**
+ * Enables modifying an existing resource.
+ * Endpoints: PUT or PATCH /[entity-collection-name]/{id}
+ */
+export interface UpdateActionSchema extends ActionSchema {
+  kind: 'update'
+  /**
+   * The allowed HTTP methods for updates. Default: PATCH only.
+   *
+   * These two methods represent the two common ways to update a resource:
+   * - PUT: Replaces the entire resource with the provided data.
+   * - PATCH: Applies a partial update to the resource, allowing for specific fields to be modified.
+   */
+  allowedMethods: ('PUT' | 'PATCH')[]
+}
+
+/**
+ * Enables modifying an existing resource.
+ * Endpoints: PUT or PATCH /[entity-collection-name]/{id}
+ */
+export class UpdateAction extends Action implements UpdateActionSchema {
+  @observed() override accessor kind: 'update'
+  @observed({ deep: true }) accessor allowedMethods: ('PUT' | 'PATCH')[]
+
+  constructor(state: Partial<UpdateActionSchema> = {}) {
+    super(state)
+    this.kind = 'update'
+    this.allowedMethods = state.allowedMethods ? [...state.allowedMethods] : ['PATCH']
+  }
+
+  override toJSON(): UpdateActionSchema {
+    return {
+      ...(super.toJSON() as UpdateActionSchema),
+      kind: 'update',
+      allowedMethods: structuredClone(toRaw(this, this.allowedMethods)) as ('PUT' | 'PATCH')[],
+    }
+  }
+
+  static isUpdateAction(action: Action): action is UpdateAction {
+    return action.kind === 'update'
+  }
+
+  static isUpdateActionSchema(schema: ActionSchema): schema is UpdateActionSchema {
+    return schema.kind === 'update'
+  }
+}