@rippling/rippling-sdk 0.2.0-alpha.108 → 0.2.0-alpha.110

package/src/lib/manifest/definitions/README.md

@@ -0,0 +1,89 @@
+# Component definitions
+
+`defineX` helpers create reusable metadata definitions. Objects, functions, and ACP agents also expose runtime operations that accept an authenticated client per call.
+
+## Usage
+
+```ts
+import {
+  RipplingSDK,
+  defineCustomObject,
+  defineListView,
+  defineManifest,
+  fields,
+  eq,
+} from '@rippling/rippling-sdk';
+
+export const Ticket = defineCustomObject({
+  apiName: 'ticket__c',
+  name: 'Ticket',
+  description: 'Support tickets',
+  fields: { title__c: fields.text({ label: 'Title' }) },
+});
+
+export const Tickets = defineListView(Ticket, {
+  apiName: 'all_tickets__c',
+  name: 'All tickets',
+  description: 'Support tickets',
+  fields: [Ticket.fields.title__c],
+  isPublic: true,
+});
+
+export default defineManifest({ components: [Ticket, Tickets] });
+
+Ticket.apiName;
+Ticket.fields.title__c;
+
+const client = new RipplingSDK({ bearerToken: 'YOUR_TOKEN' });
+await Ticket.records.create(client, { name: 'Bug', title__c: 'Bug' });
+// Equivalent client-helper form:
+await client.objects(Ticket).create({ name: 'Bug', title__c: 'Bug' });
+await Ticket.records.list(client, { where: eq(Ticket.fields.title__c, 'Bug') });
+await Ticket.records.query(client, { query: "(title__c == 'Bug')" });
+```
+
+Definitions retain no credentials and remain reusable manifest inputs with either call style. Constructor-based authoring remains available through `ManifestBuilder`.
+
+- Objects expose typed `records` operations and filters such as `eq(Ticket.fields.title__c, 'Bug')`. `Ticket.fields` contains local field tokens; deployed metadata is available through `Ticket.schema.retrieve(client)` and `Ticket.schema.fields.list(client)`.
+- Functions expose `fn.execute(client, input)` and `fn.executions` for listing, retrieval, and logs. `fn.handler(...)` shares the input/output contract. The client-helper form is `client.function(fn)`.
+- ACP agents expose `agent.retrieve(client)` and `agent.sessions.create/list(client, ...)`. The client-helper form is `client.agent(agent)`.
+
+Operations reuse generated request options and pagination helpers. TypeScript checks local field values and references; live use also requires backend support for API-name creation and runtime routing.
+
+Definition-based record writes accept `null` for optional writable custom fields, including fields declared with `nullable: true`. Required and computed fields retain their write restrictions. Numeric fields and numeric formulas decode API decimal strings to JavaScript numbers, with JavaScript's usual floating-point precision.
+
+## Composition and source files
+
+`defineManifest` collects dependencies declared by the component's `references` hook, such as an app's pages and their rendering functions. Include other desired children as roots: listing an object does not include every view or action created for it. Raw strings and opaque JSON do not create dependencies.
+
+New custom objects require at least one list view, including objects included through lookup dependencies. Add their views as explicit roots.
+
+Composition snapshots the existing `{ metadata, components }` wire format. Identical serialized keys are deduplicated; different configs with the same key are rejected. Fields and layouts use object-scoped names; native fields and sections use model-scoped names. Custom-object sections, actions, views, validations, and record-triggered flows require names unique across objects because their backend lookups or installation maps are company-scoped. Authored metadata replaces generated defaults, and base/extended objects share generated layouts.
+
+Supply complete API names: objects, categories, nested field and section keys, actions, validations, record-triggered flows, workflows, pages, custom skills, and ACP agents require `__c`. The helpers validate names rather than adding suffixes. Category string references also use the complete API name. Native sections require `__cfs`; native fields require `__cfv2`. Employee custom fields use `applicableGroupId` for an existing applicability group. Owner permissions are created by the backend when it installs the object.
+
+Definitions with file sources require `compileManifest(manifest, readSource)` or `rippling project export` before JSON serialization. Source files are read only at compilation, unchanged; export does not bundle local imports. `fn.setCode(...)` and `agent.setSource(...)` replace file sources for subsequent manifests. Previously composed manifests keep their source snapshots.
+
+`defineCustomSkill` emits its API name as both `api_name` and `source_skill_id`, with `identity_format_version: 2`. Skill references use that API name; legacy constructors keep their source-ID format.
+
+## Adding a component
+
+Keep each component’s types, construction, serialization, reference handling, and runtime operations in one module using `defineComponent`. Related components reuse the owning module’s helpers:
+
+1. Put public input/result types first, followed by a named exported `defineX` function. Keep runtime methods explicit in public interfaces. The factory constructs its result and calls the component adapter’s `register(result, ...arguments)`; a metadata class is optional.
+2. Add `references` when there are local dependencies; it defaults to none. For replaceable references, return a callback reading the current state used by serialization; see [action.ts](./action.ts).
+3. Implement `serialize(definition)` to return its wire config. Existing `toDict()` methods are used automatically when no serializer is supplied. Use `compileBatch(definitions, context)` for schema expansion or merging, as in [custom-object.ts](./custom-object.ts). Return `{ config, fallback: true }` only for generated defaults that should yield to authored metadata.
+4. Export the named factory and public types from [index.ts](./index.ts). Place the `defineComponent({ type, define: defineX, ... })` adapter and private serialization/reference helpers below the public API.
+
+Use these existing implementations as references:
+
+- [app.ts](./app.ts): minimal registration reusing a metadata class and serializer. `detachedManifestScope` keeps constructor effects separate from legacy builders.
+- [object-settings.ts](./object-settings.ts): a definition without a metadata class, with its own fields and serialization.
+- [function.ts](./function.ts) and [custom-object.ts](./custom-object.ts): runtime methods taking a structural authenticated context. Add any client accessor in [client.ts](../../../client.ts) by forwarding to the same operations.
+- [component.ts](./component.ts): wire config types, serialized key extraction, and `sourceEntry` for deferred file loading. Add a new kind to `ComponentType` here or `ManifestComponentType` in [manifest-builder.ts](../manifest-builder.ts), and define its identifying wire fields in `MetadataConfig`. Scoped or singleton kinds also need an `entryKey` case.
+
+Component implementations own serialization; there is no separate identity declaration. Runtime methods and client accessors are explicit implementations, not generated by `defineComponent`. New metadata kinds and operations require corresponding backend contracts.
+
+Verify wire output, dependencies, scoped conflicts, and public types. For mutable definitions, check that subsequent manifests use current references while prior snapshots remain unchanged. Runtime checks should cover the endpoint contract and pagination where applicable.
+
+Run `yarn test --runInBand` and `yarn lint`.

package/src/lib/manifest/definitions/_object-records.ts

@@ -0,0 +1,218 @@
+import {
+  createCustomObjectRecordAdapter,
+  CustomObjectRecordValidationError,
+} from '../../../core/platform/custom-objects/manager';
+import {
+  validateCreateInput,
+  validateUpdateInput,
+  type ValidationIssue,
+} from '../../../core/platform/custom-objects/validation';
+import type {
+  AnyCustomObjectDefinition,
+  AnyFieldDefinition,
+  CreateInput,
+  UpdateInput,
+  FieldValue,
+  RecordShape,
+} from '../../../core/platform/custom-objects/types';
+import type { CustomObjectDataRow } from '../../../resources/custom-objects/records';
+import type { ObjectRecords, ObjectRecordsContext } from './custom-object';
+
+type NullableFields<D extends AnyCustomObjectDefinition> = {
+  [K in keyof D['fields']]: D['fields'][K] extends { writable: true; required: false } ? K : never;
+}[keyof D['fields']];
+
+/** Definition-based writes accept null for writable, non-required custom fields. */
+export type ObjectCreateInput<D extends AnyCustomObjectDefinition> = Omit<
+  CreateInput<D>,
+  NullableFields<D>
+> & {
+  [K in NullableFields<D>]?: FieldValue<D['fields'][K]> | null;
+};
+
+export type ObjectUpdateInput<D extends AnyCustomObjectDefinition> = Omit<
+  UpdateInput<D>,
+  NullableFields<D>
+> & {
+  [K in NullableFields<D>]?: FieldValue<D['fields'][K]> | null;
+};
+
+export type ObjectBulkUpdateInput<D extends AnyCustomObjectDefinition> = {
+  readonly id: string;
+} & ObjectUpdateInput<D>;
+
+/** Reuse the existing value checks, excluding only explicitly allowed null custom-field values. */
+function inputIssues(
+  definition: AnyCustomObjectDefinition,
+  input: Record<string, unknown>,
+  operation: 'create' | 'update',
+): readonly ValidationIssue[] {
+  if (input == null || typeof input !== 'object' || Array.isArray(input))
+    return [{ path: '', message: 'Expected a record object.' }];
+  const checked = { ...input };
+  for (const [key, field] of Object.entries(definition.fields)) {
+    if (field.writable && !field.required && checked[key] === null) delete checked[key];
+  }
+  return (operation === 'create' ? validateCreateInput : validateUpdateInput)(definition, checked).issues;
+}
+
+export function assertObjectInput(
+  definition: AnyCustomObjectDefinition,
+  input: Record<string, unknown>,
+  operation: 'create' | 'update',
+): void {
+  const issues = inputIssues(definition, input, operation);
+  if (issues.length > 0) throw new CustomObjectRecordValidationError(definition, operation, issues);
+}
+
+function referenceID(value: unknown): unknown {
+  return value != null && typeof value === 'object' && 'id' in value ? value.id : value;
+}
+
+function serializeInput(
+  definition: AnyCustomObjectDefinition,
+  input: Record<string, unknown>,
+): Record<string, unknown> {
+  const wire: Record<string, unknown> = {};
+  for (const key of ['name', 'external_id', 'owner_role']) {
+    if (Object.prototype.hasOwnProperty.call(input, key) && input[key] !== undefined)
+      wire[key] = key === 'owner_role' ? referenceID(input[key]) : input[key];
+  }
+  for (const [key, field] of Object.entries(definition.fields)) {
+    if (!Object.prototype.hasOwnProperty.call(input, key) || input[key] === undefined) continue;
+    wire[field.apiName] =
+      field.kind === 'lookup' || field.kind === 'parent-child' || field.kind === 'file' ?
+        referenceID(input[key])
+      : input[key];
+  }
+  return wire;
+}
+
+function lookup(value: unknown, apiName: string) {
+  if (typeof value === 'string') return { id: value, apiName };
+  if (value != null && typeof value === 'object' && 'id' in value && typeof value.id === 'string') {
+    return {
+      id: value.id,
+      apiName: 'apiName' in value && typeof value.apiName === 'string' ? value.apiName : apiName,
+    };
+  }
+  return null;
+}
+
+function fieldValue(field: AnyFieldDefinition, value: unknown): unknown {
+  if (value == null) return null;
+  switch (field.kind) {
+    case 'lookup':
+    case 'parent-child':
+      return lookup(value, field.targetApiName ?? 'unknown');
+    case 'file':
+      return (
+        typeof value === 'string' ? value
+        : value != null && typeof value === 'object' && 'id' in value && typeof value.id === 'string' ?
+          { id: value.id }
+        : null
+      );
+    case 'number':
+    case 'currency':
+    case 'percentage':
+    case 'formula-number':
+    case 'formula-currency':
+    case 'formula-percentage': {
+      const numeric =
+        typeof value === 'number' ? value
+        : typeof value === 'string' && /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i.test(value) ?
+          Number(value)
+        : NaN;
+      if (!Number.isFinite(numeric))
+        throw new TypeError(`Invalid numeric value for ${field.apiName}: expected a finite number.`);
+      return numeric;
+    }
+    default:
+      return value;
+  }
+}
+
+function decodeRecord<D extends AnyCustomObjectDefinition>(
+  definition: D,
+  row: CustomObjectDataRow,
+): RecordShape<D> {
+  const record: Record<string, unknown> = { id: row.id, name: row.name };
+  for (const key of ['created_at', 'updated_at', 'system_updated_at', 'external_id'])
+    record[key] = typeof row[key] === 'string' ? row[key] : null;
+  for (const key of ['owner_role', 'created_by', 'last_modified_by'])
+    record[key] = lookup(row[key], 'Employee');
+  for (const [key, field] of Object.entries(definition.fields))
+    record[key] = fieldValue(field as AnyFieldDefinition, row[field.apiName]);
+  return record as RecordShape<D>;
+}
+
+/** Definition-specific nullability and decoding; the shared manager and legacy constructors are unchanged. */
+export function createObjectRecords<D extends AnyCustomObjectDefinition>(
+  definition: D,
+): Readonly<ObjectRecords<D>> {
+  const adapter = (ctx: ObjectRecordsContext) => createCustomObjectRecordAdapter(ctx.customObjects.records);
+  const decode = (row: CustomObjectDataRow) => decodeRecord(definition, row);
+  const serializeBatch = (rows: readonly Record<string, unknown>[], operation: 'create' | 'update') => {
+    const issues = rows.flatMap((row, index) => {
+      if (row == null || typeof row !== 'object' || Array.isArray(row))
+        return [{ path: `[${index}]`, message: 'Expected a record object.' }];
+      const { id, ...patch } = row;
+      return [
+        ...(operation === 'update' && (typeof id !== 'string' || id.length === 0) ?
+          [{ path: `[${index}].id`, message: 'Expected a record id string.' }]
+        : []),
+        ...inputIssues(definition, operation === 'update' ? patch : row, operation).map((issue) => ({
+          ...issue,
+          path: `[${index}].${issue.path}`,
+        })),
+      ];
+    });
+    if (issues.length > 0)
+      throw new CustomObjectRecordValidationError(
+        definition,
+        operation === 'create' ? 'bulk-create' : 'bulk-update',
+        issues,
+      );
+    return rows.map((row) =>
+      operation === 'create' ?
+        serializeInput(definition, row)
+      : { id: row['id'], ...serializeInput(definition, row) },
+    );
+  };
+  const query = async (ctx: ObjectRecordsContext, options: Parameters<ObjectRecords<D>['query']>[1]) => {
+    const page = await adapter(ctx).query(definition.apiName, options ?? {});
+    return { cursor: page.cursor, results: page.results.map(decode) };
+  };
+  return Object.freeze<ObjectRecords<D>>({
+    async create(ctx, input) {
+      assertObjectInput(definition, input, 'create');
+      return decode(await adapter(ctx).create(definition.apiName, serializeInput(definition, input)));
+    },
+    async createMany(ctx, rows, options) {
+      const rowsToWrite = serializeBatch(rows, 'create');
+      return (await adapter(ctx).bulkCreate(definition.apiName, { ...options, rowsToWrite })).map(decode);
+    },
+    async get(ctx, recordID) {
+      return decode(await adapter(ctx).retrieve(definition.apiName, recordID));
+    },
+    async getByExternalID(ctx, externalID) {
+      return decode(await adapter(ctx).retrieveByExternalID(definition.apiName, externalID));
+    },
+    async update(ctx, recordID, patch) {
+      assertObjectInput(definition, patch, 'update');
+      return decode(
+        await adapter(ctx).update(definition.apiName, recordID, serializeInput(definition, patch)),
+      );
+    },
+    async updateMany(ctx, rows, options) {
+      const rowsToUpdate = serializeBatch(rows, 'update');
+      return (await adapter(ctx).bulkUpdate(definition.apiName, { ...options, rowsToUpdate })).map(decode);
+    },
+    delete: (ctx, recordID) => adapter(ctx).delete(definition.apiName, recordID),
+    deleteMany: (ctx, recordIDs, options) =>
+      adapter(ctx).bulkDelete(definition.apiName, { ...options, rowsToDelete: recordIDs }),
+    list: (ctx, { where, ...options } = {}) =>
+      query(ctx, { ...options, ...(where === undefined ? {} : { query: where.text }) }),
+    query,
+  });
+}

package/src/lib/manifest/definitions/action.ts

@@ -0,0 +1,31 @@
+import { defineComponent, withApiName, validateCustomApiName, type ComponentDefinition } from './component';
+import { CustomObjectAction, type CustomObjectActionProps } from '../custom-object-action';
+import { manifestObject, type ObjectReference } from './custom-object';
+
+export type DefineActionProps = Omit<CustomObjectActionProps, 'actionId' | 'apiName'> & {
+  apiName: `${string}__c`;
+};
+
+export function defineAction(object: ObjectReference, props: DefineActionProps): CustomObjectAction {
+  validateCustomApiName(props.apiName);
+  const action = withApiName(
+    new CustomObjectAction(manifestObject(object), { ...props, actionId: props.apiName }),
+    props.apiName,
+  );
+  currentFunction.set(action, props.function);
+  const setFunction = action.setFunction.bind(action);
+  action.setFunction = (definition) => {
+    setFunction(definition);
+    currentFunction.set(action, definition);
+    return action;
+  };
+  return actionComponent.register(action, object, props);
+}
+
+const currentFunction = new WeakMap<CustomObjectAction, CustomObjectActionProps['function']>();
+
+const actionComponent: ComponentDefinition<typeof defineAction> = defineComponent({
+  type: 'CUSTOM_OBJECT_ACTION',
+  define: defineAction,
+  references: (definition, object) => () => [object, currentFunction.get(definition)!],
+});

package/src/lib/manifest/definitions/agent.ts

@@ -0,0 +1,149 @@
+import { ACPAgent, type ACPAgentProps, type ACPAgentSourceFile } from '../acp-agent';
+import { detachedManifestScope, defineComponent, sourceEntry, validateCustomApiName } from './component';
+import type { RipplingSDK } from '../../../client';
+import type { RequestOptions } from '../../../internal/request-options';
+import type {
+  SessionCreateParams,
+  SessionListParams,
+  SessionCreateResponse,
+  SessionListResponse,
+  SessionListResponsesPageCursorURL,
+} from '../../../resources/agents/sessions/sessions';
+import type { AgentRetrieveResponse } from '../../../resources/agents/agents';
+import type { APIPromise } from '../../../core/api-promise';
+import type { PagePromise } from '../../../core/pagination';
+
+export type DefinedAgentProps = { apiName: `${string}__c` } & (
+  | (ACPAgentProps & { source?: never })
+  | (Omit<ACPAgentProps, 'files' | 'entrypoint'> & { source: URL; files?: never; entrypoint?: never })
+);
+
+/** Authenticated agent resources supplied per call. */
+export interface AgentOperationsContext {
+  readonly agents: {
+    readonly retrieve: RipplingSDK['agents']['retrieve'];
+    readonly sessions: Pick<RipplingSDK['agents']['sessions'], 'create' | 'list'>;
+  };
+}
+
+export interface AgentSessions {
+  create(
+    ctx: AgentOperationsContext,
+    params: Omit<SessionCreateParams, 'agent_id'>,
+    options?: RequestOptions,
+  ): APIPromise<SessionCreateResponse>;
+  list(
+    ctx: AgentOperationsContext,
+    params?: SessionListParams,
+    options?: RequestOptions,
+  ): PagePromise<SessionListResponsesPageCursorURL, SessionListResponse>;
+}
+
+export interface AgentOperations {
+  retrieve(ctx: AgentOperationsContext, options?: RequestOptions): APIPromise<AgentRetrieveResponse>;
+  sessions: AgentSessions;
+}
+
+export interface AgentClient {
+  retrieve(options?: RequestOptions): APIPromise<AgentRetrieveResponse>;
+  sessions: {
+    create(
+      params: Omit<SessionCreateParams, 'agent_id'>,
+      options?: RequestOptions,
+    ): APIPromise<SessionCreateResponse>;
+    list(
+      params?: SessionListParams,
+      options?: RequestOptions,
+    ): PagePromise<SessionListResponsesPageCursorURL, SessionListResponse>;
+  };
+}
+
+export function defineAgent(props: DefinedAgentProps): DefinedAgent {
+  if (props.source !== undefined && (props.files !== undefined || props.entrypoint !== undefined))
+    throw new Error('Define an agent with either source or files/entrypoint, not both.');
+  return agentComponent.register(new DefinedAgent(props), props);
+}
+
+export class DefinedAgent extends ACPAgent {
+  private _source: URL | undefined;
+  readonly retrieve: (
+    ctx: AgentOperationsContext,
+    options?: RequestOptions,
+  ) => APIPromise<AgentRetrieveResponse>;
+  readonly sessions: AgentSessions;
+  constructor(props: DefinedAgentProps) {
+    validateCustomApiName(props.apiName);
+    if (props.source !== undefined && props.source.protocol !== 'file:')
+      throw new Error('Component source must be a file URL.');
+    super(
+      detachedManifestScope,
+      props.source !== undefined ? { ...props, files: [], entrypoint: 'index.ts' } : (props as ACPAgentProps),
+    );
+    this._source = props.source === undefined ? undefined : new URL(props.source.href);
+    const operations = createAgentOperations(this);
+    this.retrieve = operations.retrieve;
+    this.sessions = operations.sessions;
+  }
+
+  get source(): URL | undefined {
+    return this._source;
+  }
+
+  /** Replaces inline files or a file-backed source with the supplied files and entrypoint. */
+  override setSource(files: ACPAgentSourceFile[], entrypoint: string): this {
+    super.setSource(files, entrypoint);
+    this._source = undefined;
+    return this;
+  }
+}
+
+interface AgentMetadata {
+  type: 'ACP_AGENT';
+  api_name: string;
+  source_agent_id: string;
+  name: string;
+  entrypoint: string;
+  files: { type: 'ACP_AGENT'; path: string; content: string; kind: string }[];
+}
+
+/** @internal Shared with the legacy client helper, including constructor-based agent references. */
+function createAgentOperations(definition: ACPAgent): AgentOperations {
+  return {
+    retrieve: (ctx: AgentOperationsContext, options?: RequestOptions) =>
+      ctx.agents.retrieve(definition.getApiName(), options),
+    sessions: {
+      create: (
+        ctx: AgentOperationsContext,
+        params: Omit<SessionCreateParams, 'agent_id'>,
+        options?: RequestOptions,
+      ) => ctx.agents.sessions.create({ ...params, agent_id: definition.getApiName() }, options),
+      list: (ctx: AgentOperationsContext, params?: SessionListParams, options?: RequestOptions) =>
+        ctx.agents.sessions.list(definition.getApiName(), params, options),
+    },
+  };
+}
+
+const agentComponent = defineComponent({
+  type: 'ACP_AGENT',
+  define: defineAgent,
+  serialize: (definition) =>
+    sourceEntry(definition.toDict() as AgentMetadata, definition.source, (config, content) => ({
+      ...config,
+      files: [{ type: 'ACP_AGENT' as const, path: 'index.ts', content, kind: 'typescript' }],
+      entrypoint: 'index.ts',
+    })),
+});
+
+/** @internal Forward client helpers to the definition operations. */
+export function createAgentClient(ctx: AgentOperationsContext, definition: ACPAgent): AgentClient {
+  const operations = createAgentOperations(definition);
+  return {
+    retrieve: (options?: RequestOptions) => operations.retrieve(ctx, options),
+    sessions: {
+      create: (params: Omit<SessionCreateParams, 'agent_id'>, options?: RequestOptions) =>
+        operations.sessions.create(ctx, params, options),
+      list: (params?: SessionListParams, options?: RequestOptions) =>
+        operations.sessions.list(ctx, params, options),
+    },
+  };
+}

package/src/lib/manifest/definitions/app.ts

@@ -0,0 +1,12 @@
+import { defineComponent, detachedManifestScope, type ComponentDefinition } from './component';
+import { App, type AppProps } from '../app';
+
+export function defineApp(props: AppProps): App {
+  return appComponent.register(new App(detachedManifestScope, props), props);
+}
+
+const appComponent: ComponentDefinition<typeof defineApp> = defineComponent({
+  type: 'CUSTOM_APP',
+  define: defineApp,
+  references: (_definition, props) => props.pages,
+});

package/src/lib/manifest/definitions/category.ts

@@ -0,0 +1,35 @@
+import type { CustomObjectCategoryDefinition } from '../../../core/platform/custom-objects/category';
+import { Category, type CategoryProps } from '../category';
+import { detachedManifestScope, defineComponent, validateCustomApiName } from './component';
+
+export type DefineCustomObjectCategoryProps<TApiName extends `${string}__c` = `${string}__c`> =
+  CategoryProps & { apiName: TApiName };
+
+export function defineCategory<const TApiName extends `${string}__c`>(
+  props: DefineCustomObjectCategoryProps<TApiName>,
+): Category & CustomObjectCategoryDefinition<TApiName extends `${infer N}__c` ? N : never>;
+export function defineCategory(props: CategoryProps): Category | CustomObjectCategoryDefinition {
+  validateCustomApiName(props.apiName);
+  return categoryComponent.register(
+    Object.assign(new Category(detachedManifestScope, props), {
+      apiName: props.apiName,
+      name: props.apiName.replace(/__c$/, ''),
+      displayName: props.name,
+      description: props.description,
+    }),
+    props,
+  );
+}
+
+export const defineCustomObjectCategory = defineCategory;
+
+export const categoryComponent = defineComponent({
+  type: 'CUSTOM_CATEGORY',
+  define: defineCategory,
+  serialize: (definition) => ({
+    type: 'CUSTOM_CATEGORY',
+    api_name: definition.apiName,
+    name: definition.displayName,
+    description: definition.description ?? '',
+  }),
+});