@spatialwalk/avatarkit 1.0.0-beta.35 → 1.0.0-beta.37

package/CHANGELOG.md

@@ -5,6 +5,19 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.0.0-beta.37] - 2025-12-24
+
+### 🐛 Bugfix
+- Various bug fixes and improvements
+
+## [1.0.0-beta.36] - 2025-12-20
+
+### ✨ New Features
+- **Audio Sample Rate Configuration** - Added configurable audio sample rate support in SDK initialization
+  - Added `audioFormat` configuration option with `channelCount` (fixed to 1) and `sampleRate` (supports: 8000, 16000, 22050, 24000, 32000, 44100, 48000 Hz, default: 16000)
+  - Audio recording and playback now automatically use the configured sample rate
+  - Vanilla demo updated with sample rate dropdown selector for easy testing
+
 ## [1.0.0-beta.35] - 2025-12-16
 
 ### 🔄 API Changes

package/README.md

@@ -45,6 +45,10 @@ const configuration: Configuration = {
   // - LogLevel.error: Only error logs
   // - LogLevel.warning: Warning and error logs
   // - LogLevel.all: All logs (info, warning, error)
+  audioFormat: { // Optional, default is { channelCount: 1, sampleRate: 16000 }
+    channelCount: 1, // Fixed to 1 (mono)
+    sampleRate: 16000 // Supported: 8000, 16000, 22050, 24000, 32000, 44100, 48000 Hz
+  }
 }
 
 await AvatarSDK.initialize('your-app-id', configuration)
@@ -68,8 +72,8 @@ const avatarView = new AvatarView(avatar, container)
 // 4. Start real-time communication (SDK mode only)
 await avatarView.avatarController.start()
 
-// 5. Send audio data (SDK mode, must be 16kHz mono PCM16 format)
-const audioData = new ArrayBuffer(1024) // Example: 16kHz PCM16 audio data
+// 5. Send audio data (SDK mode, must be mono PCM16 format matching configured sample rate)
+const audioData = new ArrayBuffer(1024) // Example: PCM16 audio data at configured sample rate
 avatarView.avatarController.send(audioData, false) // Send audio data
 avatarView.avatarController.send(audioData, true) // end=true marks the end of current conversation round
 ```
@@ -190,23 +194,37 @@ RenderSystem → WebGPU/WebGL → Canvas rendering
 
 ### Audio Format Requirements
 
-**⚠️ Important:** The SDK requires audio data to be in **16kHz mono PCM16** format:
+**⚠️ Important:** The SDK requires audio data to be in **mono PCM16** format:
 
-- **Sample Rate**: 16kHz (16000 Hz) - This is a backend requirement
-- **Channels**: Mono (single channel)
+- **Sample Rate**: Configurable via `audioFormat.sampleRate` in SDK initialization (default: 16000 Hz)
+  - Supported sample rates: 8000, 16000, 22050, 24000, 32000, 44100, 48000 Hz
+  - The configured sample rate will be used for both audio recording and playback
+- **Channels**: Mono (single channel) - Fixed to 1 channel
 - **Format**: PCM16 (16-bit signed integer, little-endian)
 - **Byte Order**: Little-endian
 
 **Audio Data Format:**
 - Each sample is 2 bytes (16-bit)
 - Audio data should be provided as `ArrayBuffer` or `Uint8Array`
-- For example: 1 second of audio = 16000 samples × 2 bytes = 32000 bytes
+- For example, with 16kHz sample rate: 1 second of audio = 16000 samples × 2 bytes = 32000 bytes
+- For 48kHz sample rate: 1 second of audio = 48000 samples × 2 bytes = 96000 bytes
 
 **Resampling:**
-- If your audio source is at a different sample rate (e.g., 24kHz, 48kHz), you must resample it to 16kHz before sending to the SDK
+- If your audio source is at a different sample rate, you must resample it to match the configured sample rate before sending to the SDK
 - For high-quality resampling, we recommend using Web Audio API's `OfflineAudioContext` with anti-aliasing filtering
 - See example projects for resampling implementation
 
+**Configuration Example:**
+```typescript
+const configuration: Configuration = {
+  environment: Environment.cn,
+  audioFormat: {
+    channelCount: 1, // Fixed to 1 (mono)
+    sampleRate: 48000 // Choose from: 8000, 16000, 22050, 24000, 32000, 44100, 48000
+  }
+}
+```
+
 ## 📚 API Reference
 
 ### AvatarSDK
@@ -431,6 +449,12 @@ interface Configuration {
   environment: Environment
   drivingServiceMode?: DrivingServiceMode  // Optional, default is 'sdk' (SDK mode)
   logLevel?: LogLevel  // Optional, default is 'off' (no logs)
+  audioFormat?: AudioFormat  // Optional, default is { channelCount: 1, sampleRate: 16000 }
+}
+
+interface AudioFormat {
+  readonly channelCount: 1  // Fixed to 1 (mono)
+  readonly sampleRate: number  // Supported: 8000, 16000, 22050, 24000, 32000, 44100, 48000 Hz, default: 16000
 }
 ```
 
@@ -459,6 +483,11 @@ enum LogLevel {
   - `LogLevel.error`: Only error logs
   - `LogLevel.warning`: Warning and error logs
   - `LogLevel.all`: All logs (info, warning, error)
+- `audioFormat`: Configures audio sample rate and channel count
+  - `channelCount`: Fixed to 1 (mono channel)
+  - `sampleRate`: Audio sample rate in Hz (default: 16000)
+    - Supported values: 8000, 16000, 22050, 24000, 32000, 44100, 48000
+    - The configured sample rate will be used for both audio recording and playback
 - `sessionToken`: Set separately via `AvatarSDK.setSessionToken()`, not in Configuration
 
 ```typescript
@@ -500,13 +529,15 @@ enum ConnectionState {
 ```typescript
 enum ConversationState {
   idle = 'idle',      // Idle state (breathing animation)
-  playing = 'playing' // Playing state (active conversation)
+  playing = 'playing', // Playing state (active conversation)
+  pausing = 'pausing' // Pausing state (paused during playback)
 }
 ```
 
 **State Description:**
 - `idle`: Avatar is in idle state (breathing animation), waiting for conversation to start
 - `playing`: Avatar is playing conversation content (including during transition animations)
+- `pausing`: Avatar playback is paused (e.g., when `end=false` and waiting for more audio data)
 
 **Note:** During transition animations, the target state is notified immediately:
 - When transitioning from `idle` to `playing`, the `playing` state is notified immediately

package/dist/{StreamingAudioPlayer-eWy8xl8G.js → StreamingAudioPlayer-gV0axCZe.js}

@@ -1,7 +1,7 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { A as APP_CONFIG, e as errorToMessage, l as logEvent, a as logger } from "./index-DgkjYDp2.js";
+import { A as APP_CONFIG, e as errorToMessage, l as logEvent, a as logger } from "./index-DxIr4cus.js";
 class StreamingAudioPlayer {
   constructor(options) {
     __publicField(this, "audioContext", null);
@@ -17,9 +17,13 @@ class StreamingAudioPlayer {
     __publicField(this, "isPlaying", false);
     __publicField(this, "isPaused", false);
     __publicField(this, "autoStartEnabled", true);
+    __publicField(this, "autoContinue", false);
     __publicField(this, "audioChunks", []);
     __publicField(this, "scheduledChunks", 0);
     __publicField(this, "activeSources", /* @__PURE__ */ new Set());
+    __publicField(this, "lastScheduledChunkEndTime", 0);
+    __publicField(this, "lastGetCurrentTimeLog", 0);
+    __publicField(this, "scheduledChunkInfo", []);
     __publicField(this, "gainNode", null);
     __publicField(this, "volume", 1);
     __publicField(this, "onEndedCallback");
@@ -70,6 +74,13 @@ class StreamingAudioPlayer {
       isPlaying: this.isPlaying,
       scheduledChunks: this.scheduledChunks
     });
+    if (this.autoContinue && this.isPaused) {
+      this.log("[StreamingAudioPlayer] autoContinue=true, auto-resuming playback");
+      this.autoContinue = false;
+      this.resume().catch((err) => {
+        logger.errorWithError("Failed to auto-resume playback:", err);
+      });
+    }
     if (!this.isPlaying && this.autoStartEnabled && this.audioChunks.length > 0) {
       this.log("[StreamingAudioPlayer] Auto-starting playback from addChunk");
       this.startPlayback();
@@ -88,6 +99,7 @@ class StreamingAudioPlayer {
     this.pausedTimeOffset = 0;
     this.pausedAt = 0;
     this.pausedAudioContextTime = 0;
+    this.autoContinue = false;
     this.log("Starting new session", {
       chunks: audioChunks.length
     });
@@ -107,6 +119,9 @@ class StreamingAudioPlayer {
     this.isPlaying = true;
     this.sessionStartTime = this.audioContext.currentTime;
     this.scheduledTime = this.sessionStartTime;
+    this.lastScheduledChunkEndTime = 0;
+    this.scheduledChunkInfo = [];
+    this.autoContinue = false;
     this.log("[StreamingAudioPlayer] Starting playback", {
       sessionStartTime: this.sessionStartTime,
       bufferedChunks: this.audioChunks.length,
@@ -155,16 +170,30 @@ class StreamingAudioPlayer {
       const source = this.audioContext.createBufferSource();
       source.buffer = audioBuffer;
       source.connect(this.gainNode);
-      source.start(this.scheduledTime);
+      const chunkStartTime = this.scheduledTime;
+      source.start(chunkStartTime);
+      const actualStartTime = Math.max(chunkStartTime, this.audioContext.currentTime);
+      this.scheduledChunkInfo.push({
+        startTime: actualStartTime,
+        duration: audioBuffer.duration
+      });
       this.activeSources.add(source);
       source.onended = () => {
         this.activeSources.delete(source);
-        if (isLast && this.activeSources.size === 0) {
-          this.log("Last audio chunk ended, marking playback as ended");
-          this.markEnded();
+        if (this.activeSources.size === 0) {
+          const lastChunk = this.audioChunks[this.scheduledChunks - 1];
+          if (lastChunk && !lastChunk.isLast) {
+            this.log("All audio chunks ended but end=false, pausing and setting autoContinue");
+            this.autoContinue = true;
+            this.pause();
+          } else if (isLast) {
+            this.log("Last audio chunk ended, marking playback as ended");
+            this.markEnded();
+          }
         }
       };
       this.scheduledTime += audioBuffer.duration;
+      this.lastScheduledChunkEndTime = this.scheduledTime - this.sessionStartTime - this.pausedTimeOffset;
       this.scheduledChunks++;
       this.log(`[StreamingAudioPlayer] Scheduled chunk ${chunkIndex + 1}/${this.audioChunks.length}`, {
         startTime: this.scheduledTime - audioBuffer.duration,
@@ -225,8 +254,24 @@ class StreamingAudioPlayer {
       return this.pausedAt;
     }
     const currentAudioTime = this.audioContext.currentTime;
-    const elapsed = currentAudioTime - this.sessionStartTime - this.pausedTimeOffset;
-    return Math.max(0, elapsed);
+    if (this.activeSources.size === 0 && this.scheduledChunks > 0) {
+      return Math.max(0, this.lastScheduledChunkEndTime);
+    }
+    let totalPlayedDuration = 0;
+    for (let i = 0; i < this.scheduledChunkInfo.length; i++) {
+      const chunkInfo = this.scheduledChunkInfo[i];
+      const chunkEndTime = chunkInfo.startTime + chunkInfo.duration;
+      if (currentAudioTime < chunkInfo.startTime) {
+        break;
+      } else if (chunkEndTime <= currentAudioTime) {
+        totalPlayedDuration += chunkInfo.duration;
+      } else {
+        const playedTime = currentAudioTime - chunkInfo.startTime;
+        totalPlayedDuration += playedTime;
+        break;
+      }
+    }
+    return Math.max(0, totalPlayedDuration);
   }
   pause() {
     if (!this.isPlaying || this.isPaused || !this.audioContext) {
@@ -251,6 +296,7 @@ class StreamingAudioPlayer {
     if (!this.isPaused || !this.audioContext || !this.isPlaying) {
       return;
     }
+    this.autoContinue = false;
     if (this.audioContext.state === "suspended") {
       try {
         await this.audioContext.resume();
@@ -300,6 +346,7 @@ class StreamingAudioPlayer {
     this.activeSources.clear();
     this.audioChunks = [];
     this.scheduledChunks = 0;
+    this.autoContinue = false;
     this.log("[StreamingAudioPlayer] Playback stopped, state reset");
   }
   setAutoStart(enabled) {

package/dist/admin/eslint.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/admin/generated/buf/validate/validate.d.ts

@@ -0,0 +1,397 @@
+import { BinaryReader, BinaryWriter } from '@bufbuild/protobuf/wire';
+import { FieldDescriptorProto_Type } from '../../google/protobuf/descriptor';
+import { Duration } from '../../google/protobuf/duration';
+import { Timestamp } from '../../google/protobuf/timestamp';
+export declare const protobufPackage = "buf.validate";
+
+export declare enum Ignore {
+
+    IGNORE_UNSPECIFIED = 0,
+
+    IGNORE_IF_UNPOPULATED = 1,
+
+    IGNORE_IF_DEFAULT_VALUE = 2,
+
+    IGNORE_ALWAYS = 3,
+    UNRECOGNIZED = -1
+}
+export declare function ignoreFromJSON(object: any): Ignore;
+export declare function ignoreToJSON(object: Ignore): string;
+
+export declare enum KnownRegex {
+    KNOWN_REGEX_UNSPECIFIED = 0,
+
+    KNOWN_REGEX_HTTP_HEADER_NAME = 1,
+
+    KNOWN_REGEX_HTTP_HEADER_VALUE = 2,
+    UNRECOGNIZED = -1
+}
+export declare function knownRegexFromJSON(object: any): KnownRegex;
+export declare function knownRegexToJSON(object: KnownRegex): string;
+
+export interface Rule {
+    id?: string | undefined;
+    message?: string | undefined;
+    expression?: string | undefined;
+}
+
+export interface MessageRules {
+    disabled?: boolean | undefined;
+    cel: Rule[];
+}
+
+export interface OneofRules {
+    required?: boolean | undefined;
+}
+
+export interface FieldRules {
+    cel: Rule[];
+    required?: boolean | undefined;
+    ignore?: Ignore | undefined;
+    float?: FloatRules | undefined;
+    double?: DoubleRules | undefined;
+    int32?: Int32Rules | undefined;
+    int64?: Int64Rules | undefined;
+    uint32?: UInt32Rules | undefined;
+    uint64?: UInt64Rules | undefined;
+    sint32?: SInt32Rules | undefined;
+    sint64?: SInt64Rules | undefined;
+    fixed32?: Fixed32Rules | undefined;
+    fixed64?: Fixed64Rules | undefined;
+    sfixed32?: SFixed32Rules | undefined;
+    sfixed64?: SFixed64Rules | undefined;
+    bool?: BoolRules | undefined;
+    string?: StringRules | undefined;
+    bytes?: BytesRules | undefined;
+    enum?: EnumRules | undefined;
+    repeated?: RepeatedRules | undefined;
+    map?: MapRules | undefined;
+    any?: AnyRules | undefined;
+    duration?: DurationRules | undefined;
+    timestamp?: TimestampRules | undefined;
+}
+
+export interface PredefinedRules {
+    cel: Rule[];
+}
+
+export interface FloatRules {
+    const?: number | undefined;
+    lt?: number | undefined;
+    lte?: number | undefined;
+    gt?: number | undefined;
+    gte?: number | undefined;
+    in: number[];
+    notIn: number[];
+    finite?: boolean | undefined;
+    example: number[];
+}
+
+export interface DoubleRules {
+    const?: number | undefined;
+    lt?: number | undefined;
+    lte?: number | undefined;
+    gt?: number | undefined;
+    gte?: number | undefined;
+    in: number[];
+    notIn: number[];
+    finite?: boolean | undefined;
+    example: number[];
+}
+
+export interface Int32Rules {
+    const?: number | undefined;
+    lt?: number | undefined;
+    lte?: number | undefined;
+    gt?: number | undefined;
+    gte?: number | undefined;
+    in: number[];
+    notIn: number[];
+    example: number[];
+}
+
+export interface Int64Rules {
+    const?: string | undefined;
+    lt?: string | undefined;
+    lte?: string | undefined;
+    gt?: string | undefined;
+    gte?: string | undefined;
+    in: string[];
+    notIn: string[];
+    example: string[];
+}
+
+export interface UInt32Rules {
+    const?: number | undefined;
+    lt?: number | undefined;
+    lte?: number | undefined;
+    gt?: number | undefined;
+    gte?: number | undefined;
+    in: number[];
+    notIn: number[];
+    example: number[];
+}
+
+export interface UInt64Rules {
+    const?: string | undefined;
+    lt?: string | undefined;
+    lte?: string | undefined;
+    gt?: string | undefined;
+    gte?: string | undefined;
+    in: string[];
+    notIn: string[];
+    example: string[];
+}
+
+export interface SInt32Rules {
+    const?: number | undefined;
+    lt?: number | undefined;
+    lte?: number | undefined;
+    gt?: number | undefined;
+    gte?: number | undefined;
+    in: number[];
+    notIn: number[];
+    example: number[];
+}
+
+export interface SInt64Rules {
+    const?: string | undefined;
+    lt?: string | undefined;
+    lte?: string | undefined;
+    gt?: string | undefined;
+    gte?: string | undefined;
+    in: string[];
+    notIn: string[];
+    example: string[];
+}
+
+export interface Fixed32Rules {
+    const?: number | undefined;
+    lt?: number | undefined;
+    lte?: number | undefined;
+    gt?: number | undefined;
+    gte?: number | undefined;
+    in: number[];
+    notIn: number[];
+    example: number[];
+}
+
+export interface Fixed64Rules {
+    const?: string | undefined;
+    lt?: string | undefined;
+    lte?: string | undefined;
+    gt?: string | undefined;
+    gte?: string | undefined;
+    in: string[];
+    notIn: string[];
+    example: string[];
+}
+
+export interface SFixed32Rules {
+    const?: number | undefined;
+    lt?: number | undefined;
+    lte?: number | undefined;
+    gt?: number | undefined;
+    gte?: number | undefined;
+    in: number[];
+    notIn: number[];
+    example: number[];
+}
+
+export interface SFixed64Rules {
+    const?: string | undefined;
+    lt?: string | undefined;
+    lte?: string | undefined;
+    gt?: string | undefined;
+    gte?: string | undefined;
+    in: string[];
+    notIn: string[];
+    example: string[];
+}
+
+export interface BoolRules {
+    const?: boolean | undefined;
+    example: boolean[];
+}
+
+export interface StringRules {
+    const?: string | undefined;
+    len?: string | undefined;
+    minLen?: string | undefined;
+    maxLen?: string | undefined;
+    lenBytes?: string | undefined;
+    minBytes?: string | undefined;
+    maxBytes?: string | undefined;
+    pattern?: string | undefined;
+    prefix?: string | undefined;
+    suffix?: string | undefined;
+    contains?: string | undefined;
+    notContains?: string | undefined;
+    in: string[];
+    notIn: string[];
+    email?: boolean | undefined;
+    hostname?: boolean | undefined;
+    ip?: boolean | undefined;
+    ipv4?: boolean | undefined;
+    ipv6?: boolean | undefined;
+    uri?: boolean | undefined;
+    uriRef?: boolean | undefined;
+    address?: boolean | undefined;
+    uuid?: boolean | undefined;
+    tuuid?: boolean | undefined;
+    ipWithPrefixlen?: boolean | undefined;
+    ipv4WithPrefixlen?: boolean | undefined;
+    ipv6WithPrefixlen?: boolean | undefined;
+    ipPrefix?: boolean | undefined;
+    ipv4Prefix?: boolean | undefined;
+    ipv6Prefix?: boolean | undefined;
+    hostAndPort?: boolean | undefined;
+    wellKnownRegex?: KnownRegex | undefined;
+    strict?: boolean | undefined;
+    example: string[];
+}
+
+export interface BytesRules {
+    const?: Uint8Array | undefined;
+    len?: string | undefined;
+    minLen?: string | undefined;
+    maxLen?: string | undefined;
+    pattern?: string | undefined;
+    prefix?: Uint8Array | undefined;
+    suffix?: Uint8Array | undefined;
+    contains?: Uint8Array | undefined;
+    in: Uint8Array[];
+    notIn: Uint8Array[];
+    ip?: boolean | undefined;
+    ipv4?: boolean | undefined;
+    ipv6?: boolean | undefined;
+    example: Uint8Array[];
+}
+
+export interface EnumRules {
+    const?: number | undefined;
+    definedOnly?: boolean | undefined;
+    in: number[];
+    notIn: number[];
+    example: number[];
+}
+
+export interface RepeatedRules {
+    minItems?: string | undefined;
+    maxItems?: string | undefined;
+    unique?: boolean | undefined;
+    items?: FieldRules | undefined;
+}
+
+export interface MapRules {
+    minPairs?: string | undefined;
+    maxPairs?: string | undefined;
+    keys?: FieldRules | undefined;
+    values?: FieldRules | undefined;
+}
+
+export interface AnyRules {
+    in: string[];
+    notIn: string[];
+}
+
+export interface DurationRules {
+    const?: Duration | undefined;
+    lt?: Duration | undefined;
+    lte?: Duration | undefined;
+    gt?: Duration | undefined;
+    gte?: Duration | undefined;
+    in: Duration[];
+    notIn: Duration[];
+    example: Duration[];
+}
+
+export interface TimestampRules {
+    const?: Timestamp | undefined;
+    lt?: Timestamp | undefined;
+    lte?: Timestamp | undefined;
+    ltNow?: boolean | undefined;
+    gt?: Timestamp | undefined;
+    gte?: Timestamp | undefined;
+    gtNow?: boolean | undefined;
+    within?: Duration | undefined;
+    example: Timestamp[];
+}
+
+export interface Violations {
+    violations: Violation[];
+}
+
+export interface Violation {
+    field?: FieldPath | undefined;
+    rule?: FieldPath | undefined;
+    ruleId?: string | undefined;
+    message?: string | undefined;
+    forKey?: boolean | undefined;
+}
+
+export interface FieldPath {
+    elements: FieldPathElement[];
+}
+
+export interface FieldPathElement {
+    fieldNumber?: number | undefined;
+    fieldName?: string | undefined;
+    fieldType?: FieldDescriptorProto_Type | undefined;
+    keyType?: FieldDescriptorProto_Type | undefined;
+    valueType?: FieldDescriptorProto_Type | undefined;
+    index?: string | undefined;
+    boolKey?: boolean | undefined;
+    intKey?: string | undefined;
+    uintKey?: string | undefined;
+    stringKey?: string | undefined;
+}
+export declare const Rule: MessageFns<Rule>;
+export declare const MessageRules: MessageFns<MessageRules>;
+export declare const OneofRules: MessageFns<OneofRules>;
+export declare const FieldRules: MessageFns<FieldRules>;
+export declare const PredefinedRules: MessageFns<PredefinedRules>;
+export declare const FloatRules: MessageFns<FloatRules>;
+export declare const DoubleRules: MessageFns<DoubleRules>;
+export declare const Int32Rules: MessageFns<Int32Rules>;
+export declare const Int64Rules: MessageFns<Int64Rules>;
+export declare const UInt32Rules: MessageFns<UInt32Rules>;
+export declare const UInt64Rules: MessageFns<UInt64Rules>;
+export declare const SInt32Rules: MessageFns<SInt32Rules>;
+export declare const SInt64Rules: MessageFns<SInt64Rules>;
+export declare const Fixed32Rules: MessageFns<Fixed32Rules>;
+export declare const Fixed64Rules: MessageFns<Fixed64Rules>;
+export declare const SFixed32Rules: MessageFns<SFixed32Rules>;
+export declare const SFixed64Rules: MessageFns<SFixed64Rules>;
+export declare const BoolRules: MessageFns<BoolRules>;
+export declare const StringRules: MessageFns<StringRules>;
+export declare const BytesRules: MessageFns<BytesRules>;
+export declare const EnumRules: MessageFns<EnumRules>;
+export declare const RepeatedRules: MessageFns<RepeatedRules>;
+export declare const MapRules: MessageFns<MapRules>;
+export declare const AnyRules: MessageFns<AnyRules>;
+export declare const DurationRules: MessageFns<DurationRules>;
+export declare const TimestampRules: MessageFns<TimestampRules>;
+export declare const Violations: MessageFns<Violations>;
+export declare const Violation: MessageFns<Violation>;
+export declare const FieldPath: MessageFns<FieldPath>;
+export declare const FieldPathElement: MessageFns<FieldPathElement>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};

package/dist/admin/generated/common/v1/models.d.ts

@@ -0,0 +1,29 @@
+import { BinaryReader, BinaryWriter } from '@bufbuild/protobuf/wire';
+export declare const protobufPackage = "common.v1";
+
+export interface CustomAnimation {
+    key: string;
+    pbUrl: string;
+    wavUrl: string;
+    remark: string;
+}
+export declare const CustomAnimation: MessageFns<CustomAnimation>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};