Switch to camel case

lexicons/ch/indiemusi/alpha/actor/master_owner.json lexicons/ch/indiemusi/alpha/actor/masterOwner.json

···
 {
   "lexicon": 1,
-  "id": "ch.indiemusi.alpha.actor.master_owner",
+  "id": "ch.indiemusi.alpha.actor.masterOwner",
   "defs": {
     "main": {
       "type": "record",

lexicons/ch/indiemusi/alpha/actor/publishing_owner.json lexicons/ch/indiemusi/alpha/actor/publishingOwner.json

···
 {
   "lexicon": 1,
-  "id": "ch.indiemusi.alpha.actor.publishing_owner",
+  "id": "ch.indiemusi.alpha.actor.publishingOwner",
   "defs": {
     "main": {
       "key": "literal:self",
···
       "record": {
         "type": "object",
         "properties": {
-          "first_name": {
+          "firstName": {
             "type": "string",
             "maxLength": 255
           },
-          "last_name": {
+          "lastName": {
             "type": "string",
             "maxLength": 255
           },
-          "company_name": {
+          "companyName": {
             "type": "string",
             "maxLength": 255
           },
···
             "description": "Interested Party Information (IPI) number assigned to the publishing owner by a collecting society",
             "maxLength": 11
           },
-          "collecting_society": {
+          "collectingSociety": {
             "type": "string",
             "maxLength": 255
           }

lexicons/ch/indiemusi/alpha/recording.json

···
             "type": "string",
             "description": "ISRC (International Standard Recording Code) with which the recording is registered"
           },
-          "master_owner": {
+          "masterOwner": {
             "type": "object",
             "description": "The entity (person or company) that owns the master recording rights",
             "properties": {
···
                 "type": "string",
                 "format": "did"
               },
-              "master_owner": {
+              "masterOwner": {
                 "type": "ref",
-                "ref": "ch.indiemusi.alpha.actor.master_owner"
+                "ref": "ch.indiemusi.alpha.actor.masterOwner"
               }
             }
           },
···
             "type": "integer",
             "description": "Duration of the recording in seconds"
           },
-          "audio_file": {
+          "audioFile": {
             "type": "blob",
             "size": "integer"
           }

lexicons/ch/indiemusi/alpha/release.json

···
             "description": "GTIN (Global Trade Item Number) with which the release is registered, e.g. EAN or UPC",
             "maxLength": 14
           },
-          "release_date": {
+          "releaseDate": {
             "type": "string",
             "format": "datetime"
           },
-          "artwork_image": {
+          "artworkImage": {
             "type": "blob",
             "size": "integer"
           },

lexicons/ch/indiemusi/alpha/song.json

···
       "description": "A song or musical work: the melody, lyrics, and arrangement created by composers and authors",
       "record": {
         "type": "object",
-        "required": ["title", "interested_parties"],
+        "required": ["title", "interestedParties"],
         "properties": {
           "title": {
             "type": "string",
···
             "description": "ISWC (International Standard Musical Work Code) with which the song is registered at a collecting society",
             "maxLength": 13
           },
-          "interested_parties": {
+          "interestedParties": {
             "type": "array",
             "description": "List of interested parties (authors, composers, publishers) associated with this song",
             "minLength": 1,
···
                   "type": "string",
                   "maxLength": 11
                 },
-                "collecting_society": {
+                "collectingSociety": {
                   "type": "string",
                   "maxLength": 255
                 },
-                "performance_royalties_percentage": {
+                "performanceRoyaltiesPercentage": {
                   "type": "integer",
                   "description": "Percentage of performance royalties allocated to this interested party, 10000 = 100%"
                 },
-                "mechanical_royalties_percentage": {
+                "mechanicalRoyaltiesPercentage": {
                   "type": "integer",
                   "description": "Percentage of mechanical royalties allocated to this interested party, 10000 = 100%"
                 },
···
                   "type": "string",
                   "format": "did"
                 },
-                "publishing_owner": {
+                "publishingOwner": {
                   "type": "ref",
-                  "ref": "ch.indiemusi.alpha.actor.publishing_owner"
+                  "ref": "ch.indiemusi.alpha.actor.publishingOwner"
                 }
               }
             }

src/features/actors/handlers.tsx

···
       oauthClient,
     );
 
-    const newPublishingOwner = await client.ch.indiemusi.alpha.actor
-      .publishingOwner.createRecord({
-        first_name: firstName?.trim(),
-        last_name: lastName?.trim(),
-        company_name: companyName?.trim(),
-        ipi: cleanIpi,
-        collecting_society: collectingSociety?.trim(),
-      });
+    // const newPublishingOwner = await client.ch.indiemusi.alpha.actor
+    //   .publishingOwner.createRecord({
+    //     first_name: firstName?.trim(),
+    //     last_name: lastName?.trim(),
+    //     company_name: companyName?.trim(),
+    //     ipi: cleanIpi,
+    //     collecting_society: collectingSociety?.trim(),
+    //   });
+
+    const newArtist = await client.ch.indiemusi.alpha.actor.artist.createRecord({
+      name: "Hilke"
+    })
 
     return Response.redirect(
       new URL(

src/generated_client.ts

···
 // Generated TypeScript client for AT Protocol records
-// Generated at: 2025-10-05 14:41:13 UTC
+// Generated at: 2025-10-12 08:03:29 UTC
 // Lexicons: 23
 
 /**
···
   /** ISRC (International Standard Recording Code) with which the recording is registered */
   isrc?: string;
   /** The entity (person or company) that owns the master recording rights */
-  master_owner?: Record<string, unknown>;
+  masterOwner?: Record<string, unknown>;
   /** Duration of the recording in seconds */
   duration?: number;
-  audio_file?: BlobRef;
+  audioFile?: BlobRef;
 }
 
 export type ChIndiemusiAlphaRecordingSortFields = "title" | "isrc" | "duration";
···
   artists: Record<string, unknown>[];
   /** GTIN (Global Trade Item Number) with which the release is registered, e.g. EAN or UPC */
   gtin?: string;
-  release_date?: string;
-  artwork_image?: BlobRef;
+  releaseDate?: string;
+  artworkImage?: BlobRef;
   /** List of recordings (ch.indiemusi.alpha.recording) included in this release */
   recordings: ChIndiemusiAlphaRecording[];
 }
···
 export type ChIndiemusiAlphaReleaseSortFields =
   | "title"
   | "gtin"
-  | "release_date";
+  | "releaseDate";
 
 export interface ChIndiemusiAlphaSong {
   title: string;
   /** ISWC (International Standard Musical Work Code) with which the song is registered at a collecting society */
   iswc?: string;
   /** List of interested parties (authors, composers, publishers) associated with this song */
-  interested_parties: Record<string, unknown>[];
+  interestedParties: Record<string, unknown>[];
 }
 
 export type ChIndiemusiAlphaSongSortFields = "title" | "iswc";
 
-export interface ChIndiemusiAlphaActorPublishingOwner {
-  first_name?: string;
-  last_name?: string;
-  company_name?: string;
-  /** Interested Party Information (IPI) number assigned to the publishing owner by a collecting society */
-  ipi?: string;
-  collecting_society?: string;
-}
-
-export type ChIndiemusiAlphaActorPublishingOwnerSortFields =
-  | "first_name"
-  | "last_name"
-  | "company_name"
-  | "ipi"
-  | "collecting_society";
-
 export interface ChIndiemusiAlphaActorArtist {
   name: string;
 }
···
 }
 
 export type ChIndiemusiAlphaActorMasterOwnerSortFields = "name";
+
+export interface ChIndiemusiAlphaActorPublishingOwner {
+  firstName?: string;
+  lastName?: string;
+  companyName?: string;
+  /** Interested Party Information (IPI) number assigned to the publishing owner by a collecting society */
+  ipi?: string;
+  collectingSociety?: string;
+}
+
+export type ChIndiemusiAlphaActorPublishingOwnerSortFields =
+  | "firstName"
+  | "lastName"
+  | "companyName"
+  | "ipi"
+  | "collectingSociety";
 
 export interface ComAtprotoLabelDefsLabel {
   /** Optionally, CID specifying the specific version of 'uri' resource this label applies to. */
···
   }
 }
 
-class PublishingOwnerActorAlphaIndiemusiChClient {
+class ArtistActorAlphaIndiemusiChClient {
   private readonly client: SlicesClient;
 
   constructor(client: SlicesClient) {
···
       limit?: number;
       cursor?: string;
       where?: {
-        [
-          K in
-            | ChIndiemusiAlphaActorPublishingOwnerSortFields
-            | IndexedRecordFields
-        ]?: WhereCondition;
+        [K in ChIndiemusiAlphaActorArtistSortFields | IndexedRecordFields]?:
+          WhereCondition;
       };
       orWhere?: {
-        [
-          K in
-            | ChIndiemusiAlphaActorPublishingOwnerSortFields
-            | IndexedRecordFields
-        ]?: WhereCondition;
+        [K in ChIndiemusiAlphaActorArtistSortFields | IndexedRecordFields]?:
+          WhereCondition;
       };
-      sortBy?: SortField<ChIndiemusiAlphaActorPublishingOwnerSortFields>[];
+      sortBy?: SortField<ChIndiemusiAlphaActorArtistSortFields>[];
     },
-  ): Promise<GetRecordsResponse<ChIndiemusiAlphaActorPublishingOwner>> {
+  ): Promise<GetRecordsResponse<ChIndiemusiAlphaActorArtist>> {
     return await this.client.getRecords(
-      "ch.indiemusi.alpha.actor.publishing_owner",
+      "ch.indiemusi.alpha.actor.artist",
       params,
     );
   }
 
   async getRecord(
     params: GetRecordParams,
-  ): Promise<RecordResponse<ChIndiemusiAlphaActorPublishingOwner>> {
+  ): Promise<RecordResponse<ChIndiemusiAlphaActorArtist>> {
     return await this.client.getRecord(
-      "ch.indiemusi.alpha.actor.publishing_owner",
+      "ch.indiemusi.alpha.actor.artist",
       params,
     );
   }
···
       limit?: number;
       cursor?: string;
       where?: {
-        [
-          K in
-            | ChIndiemusiAlphaActorPublishingOwnerSortFields
-            | IndexedRecordFields
-        ]?: WhereCondition;
+        [K in ChIndiemusiAlphaActorArtistSortFields | IndexedRecordFields]?:
+          WhereCondition;
       };
       orWhere?: {
-        [
-          K in
-            | ChIndiemusiAlphaActorPublishingOwnerSortFields
-            | IndexedRecordFields
-        ]?: WhereCondition;
+        [K in ChIndiemusiAlphaActorArtistSortFields | IndexedRecordFields]?:
+          WhereCondition;
       };
-      sortBy?: SortField<ChIndiemusiAlphaActorPublishingOwnerSortFields>[];
+      sortBy?: SortField<ChIndiemusiAlphaActorArtistSortFields>[];
     },
   ): Promise<CountRecordsResponse> {
     return await this.client.countRecords(
-      "ch.indiemusi.alpha.actor.publishing_owner",
+      "ch.indiemusi.alpha.actor.artist",
       params,
     );
   }
 
   async createRecord(
-    record: ChIndiemusiAlphaActorPublishingOwner,
+    record: ChIndiemusiAlphaActorArtist,
     useSelfRkey?: boolean,
   ): Promise<{ uri: string; cid: string }> {
     return await this.client.createRecord(
-      "ch.indiemusi.alpha.actor.publishing_owner",
+      "ch.indiemusi.alpha.actor.artist",
       record,
       useSelfRkey,
     );
···
 
   async updateRecord(
     rkey: string,
-    record: ChIndiemusiAlphaActorPublishingOwner,
+    record: ChIndiemusiAlphaActorArtist,
   ): Promise<{ uri: string; cid: string }> {
     return await this.client.updateRecord(
-      "ch.indiemusi.alpha.actor.publishing_owner",
+      "ch.indiemusi.alpha.actor.artist",
       rkey,
       record,
     );
···
 
   async deleteRecord(rkey: string): Promise<void> {
     return await this.client.deleteRecord(
-      "ch.indiemusi.alpha.actor.publishing_owner",
+      "ch.indiemusi.alpha.actor.artist",
       rkey,
     );
   }
 }
 
-class ArtistActorAlphaIndiemusiChClient {
+class MasterOwnerActorAlphaIndiemusiChClient {
   private readonly client: SlicesClient;
 
   constructor(client: SlicesClient) {
···
       limit?: number;
       cursor?: string;
       where?: {
-        [K in ChIndiemusiAlphaActorArtistSortFields | IndexedRecordFields]?:
-          WhereCondition;
+        [
+          K in ChIndiemusiAlphaActorMasterOwnerSortFields | IndexedRecordFields
+        ]?: WhereCondition;
       };
       orWhere?: {
-        [K in ChIndiemusiAlphaActorArtistSortFields | IndexedRecordFields]?:
-          WhereCondition;
+        [
+          K in ChIndiemusiAlphaActorMasterOwnerSortFields | IndexedRecordFields
+        ]?: WhereCondition;
       };
-      sortBy?: SortField<ChIndiemusiAlphaActorArtistSortFields>[];
+      sortBy?: SortField<ChIndiemusiAlphaActorMasterOwnerSortFields>[];
     },
-  ): Promise<GetRecordsResponse<ChIndiemusiAlphaActorArtist>> {
+  ): Promise<GetRecordsResponse<ChIndiemusiAlphaActorMasterOwner>> {
     return await this.client.getRecords(
-      "ch.indiemusi.alpha.actor.artist",
+      "ch.indiemusi.alpha.actor.masterOwner",
       params,
     );
   }
 
   async getRecord(
     params: GetRecordParams,
-  ): Promise<RecordResponse<ChIndiemusiAlphaActorArtist>> {
+  ): Promise<RecordResponse<ChIndiemusiAlphaActorMasterOwner>> {
     return await this.client.getRecord(
-      "ch.indiemusi.alpha.actor.artist",
+      "ch.indiemusi.alpha.actor.masterOwner",
       params,
     );
   }
···
       limit?: number;
       cursor?: string;
       where?: {
-        [K in ChIndiemusiAlphaActorArtistSortFields | IndexedRecordFields]?:
-          WhereCondition;
+        [
+          K in ChIndiemusiAlphaActorMasterOwnerSortFields | IndexedRecordFields
+        ]?: WhereCondition;
       };
       orWhere?: {
-        [K in ChIndiemusiAlphaActorArtistSortFields | IndexedRecordFields]?:
-          WhereCondition;
+        [
+          K in ChIndiemusiAlphaActorMasterOwnerSortFields | IndexedRecordFields
+        ]?: WhereCondition;
       };
-      sortBy?: SortField<ChIndiemusiAlphaActorArtistSortFields>[];
+      sortBy?: SortField<ChIndiemusiAlphaActorMasterOwnerSortFields>[];
     },
   ): Promise<CountRecordsResponse> {
     return await this.client.countRecords(
-      "ch.indiemusi.alpha.actor.artist",
+      "ch.indiemusi.alpha.actor.masterOwner",
       params,
     );
   }
 
   async createRecord(
-    record: ChIndiemusiAlphaActorArtist,
+    record: ChIndiemusiAlphaActorMasterOwner,
     useSelfRkey?: boolean,
   ): Promise<{ uri: string; cid: string }> {
     return await this.client.createRecord(
-      "ch.indiemusi.alpha.actor.artist",
+      "ch.indiemusi.alpha.actor.masterOwner",
       record,
       useSelfRkey,
     );
···
 
   async updateRecord(
     rkey: string,
-    record: ChIndiemusiAlphaActorArtist,
+    record: ChIndiemusiAlphaActorMasterOwner,
   ): Promise<{ uri: string; cid: string }> {
     return await this.client.updateRecord(
-      "ch.indiemusi.alpha.actor.artist",
+      "ch.indiemusi.alpha.actor.masterOwner",
       rkey,
       record,
     );
···
 
   async deleteRecord(rkey: string): Promise<void> {
     return await this.client.deleteRecord(
-      "ch.indiemusi.alpha.actor.artist",
+      "ch.indiemusi.alpha.actor.masterOwner",
       rkey,
     );
   }
 }
 
-class MasterOwnerActorAlphaIndiemusiChClient {
+class PublishingOwnerActorAlphaIndiemusiChClient {
   private readonly client: SlicesClient;
 
   constructor(client: SlicesClient) {
···
       cursor?: string;
       where?: {
         [
-          K in ChIndiemusiAlphaActorMasterOwnerSortFields | IndexedRecordFields
+          K in
+            | ChIndiemusiAlphaActorPublishingOwnerSortFields
+            | IndexedRecordFields
         ]?: WhereCondition;
       };
       orWhere?: {
         [
-          K in ChIndiemusiAlphaActorMasterOwnerSortFields | IndexedRecordFields
+          K in
+            | ChIndiemusiAlphaActorPublishingOwnerSortFields
+            | IndexedRecordFields
         ]?: WhereCondition;
       };
-      sortBy?: SortField<ChIndiemusiAlphaActorMasterOwnerSortFields>[];
+      sortBy?: SortField<ChIndiemusiAlphaActorPublishingOwnerSortFields>[];
     },
-  ): Promise<GetRecordsResponse<ChIndiemusiAlphaActorMasterOwner>> {
+  ): Promise<GetRecordsResponse<ChIndiemusiAlphaActorPublishingOwner>> {
     return await this.client.getRecords(
-      "ch.indiemusi.alpha.actor.master_owner",
+      "ch.indiemusi.alpha.actor.publishingOwner",
       params,
     );
   }
 
   async getRecord(
     params: GetRecordParams,
-  ): Promise<RecordResponse<ChIndiemusiAlphaActorMasterOwner>> {
+  ): Promise<RecordResponse<ChIndiemusiAlphaActorPublishingOwner>> {
     return await this.client.getRecord(
-      "ch.indiemusi.alpha.actor.master_owner",
+      "ch.indiemusi.alpha.actor.publishingOwner",
       params,
     );
   }
···
       cursor?: string;
       where?: {
         [
-          K in ChIndiemusiAlphaActorMasterOwnerSortFields | IndexedRecordFields
+          K in
+            | ChIndiemusiAlphaActorPublishingOwnerSortFields
+            | IndexedRecordFields
         ]?: WhereCondition;
       };
       orWhere?: {
         [
-          K in ChIndiemusiAlphaActorMasterOwnerSortFields | IndexedRecordFields
+          K in
+            | ChIndiemusiAlphaActorPublishingOwnerSortFields
+            | IndexedRecordFields
         ]?: WhereCondition;
       };
-      sortBy?: SortField<ChIndiemusiAlphaActorMasterOwnerSortFields>[];
+      sortBy?: SortField<ChIndiemusiAlphaActorPublishingOwnerSortFields>[];
     },
   ): Promise<CountRecordsResponse> {
     return await this.client.countRecords(
-      "ch.indiemusi.alpha.actor.master_owner",
+      "ch.indiemusi.alpha.actor.publishingOwner",
       params,
     );
   }
 
   async createRecord(
-    record: ChIndiemusiAlphaActorMasterOwner,
+    record: ChIndiemusiAlphaActorPublishingOwner,
     useSelfRkey?: boolean,
   ): Promise<{ uri: string; cid: string }> {
     return await this.client.createRecord(
-      "ch.indiemusi.alpha.actor.master_owner",
+      "ch.indiemusi.alpha.actor.publishingOwner",
       record,
       useSelfRkey,
     );
···
 
   async updateRecord(
     rkey: string,
-    record: ChIndiemusiAlphaActorMasterOwner,
+    record: ChIndiemusiAlphaActorPublishingOwner,
   ): Promise<{ uri: string; cid: string }> {
     return await this.client.updateRecord(
-      "ch.indiemusi.alpha.actor.master_owner",
+      "ch.indiemusi.alpha.actor.publishingOwner",
       rkey,
       record,
     );
···
 
   async deleteRecord(rkey: string): Promise<void> {
     return await this.client.deleteRecord(
-      "ch.indiemusi.alpha.actor.master_owner",
+      "ch.indiemusi.alpha.actor.publishingOwner",
       rkey,
     );
   }
 }
 
 class ActorAlphaIndiemusiChClient {
-  readonly publishingOwner: PublishingOwnerActorAlphaIndiemusiChClient;
   readonly artist: ArtistActorAlphaIndiemusiChClient;
   readonly masterOwner: MasterOwnerActorAlphaIndiemusiChClient;
+  readonly publishingOwner: PublishingOwnerActorAlphaIndiemusiChClient;
   private readonly client: SlicesClient;
 
   constructor(client: SlicesClient) {
     this.client = client;
+    this.artist = new ArtistActorAlphaIndiemusiChClient(client);
+    this.masterOwner = new MasterOwnerActorAlphaIndiemusiChClient(client);
     this.publishingOwner = new PublishingOwnerActorAlphaIndiemusiChClient(
       client,
     );
-    this.artist = new ArtistActorAlphaIndiemusiChClient(client);
-    this.masterOwner = new MasterOwnerActorAlphaIndiemusiChClient(client);
   }
 }