@pluv/types 0.0.0-canary-20261026091827

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Shoubhit Dash
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.mts

@@ -0,0 +1,567 @@
+import { StandardSchemaV1, StandardSchemaV1 as StandardSchemaV1$1 } from "@standard-schema/spec";
+import { Subject } from "wonka";
+type Constructable = {
+  new (...args: any[]): any;
+};
+type HasRequiredProperty<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? never : K; }[keyof T] extends never ? false : true;
+type Maybe<T> = T | Nil;
+type MaybePromise<T> = Promise<T> | T;
+type MaybeReadonlyArray<T> = T[] | readonly T[];
+type Nil = null | undefined;
+type OptionalPropertyNames<T> = { [K in keyof T]-?: {} extends { [P in K]: T[K]; } ? K : never; }[keyof T];
+type SpreadProperties<L, R, K extends keyof L & keyof R> = { [P in K]: L[P] | Exclude<R[P], undefined>; };
+type Id<T> = T extends Nil ? T : T extends (infer U) ? U extends Constructable ? U : { [K in keyof U]: U[K]; } : never;
+type SpreadTwo<L, R> = Id<Pick<L, Exclude<keyof L, keyof R>> & Pick<R, Exclude<keyof R, OptionalPropertyNames<R>>> & Pick<R, Exclude<OptionalPropertyNames<R>, keyof L>> & SpreadProperties<L, R, OptionalPropertyNames<R> & keyof L>>;
+type Spread<A extends readonly [...any]> = A extends [infer L, ...infer R] ? SpreadTwo<L, Spread<R>> : unknown;
+type DeepPartial<T> = { [P in keyof T]?: T[P] extends Array<infer U> ? Array<DeepPartial<U>> : T[P] extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : DeepPartial<T[P]>; };
+type DeepReadonly<T> = T extends ((...args: any[]) => any) ? T : T extends Array<infer U> ? ReadonlyArray<DeepReadonly<U>> : T extends object ? { readonly [P in keyof T]: DeepReadonly<T[P]>; } : T;
+type DeepWriteable<T> = { -readonly [P in keyof T]: DeepWriteable<T[P]>; };
+type UndefinedProps<T extends Record<string, any>, K extends keyof T = keyof T> = Id<{ [P in K]?: undefined; } & { [P in Exclude<keyof T, K>]: T[P]; }>;
+type OptionalProps<T extends Record<string, any>, K extends keyof T = keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+type NonNilProps<T extends Record<string, any>, K extends keyof T = keyof T> = Omit<T, K> & { [P in K]-?: NonNullable<T[P]>; };
+type JsonPrimitive = string | number | boolean | null;
+type Json = JsonPrimitive | Json[] | readonly Json[] | {
+  [key: string]: Json;
+};
+type JsonObject = Record<string, Json>;
+type SetKey<T, K extends keyof T, V> = Omit<T, K> & { [P in K]: V; };
+type UnionToIntersection<U> = (U extends any ? (arg: U) => any : never) extends ((arg: infer I) => void) ? I : never;
+/** `true` when `T` is `any`. `any` is the only type for which `1 & T` stays `any`. */
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type AreAllOptional<T> = [T] extends [{}] ? keyof T extends never ? true : HasRequiredProperty<T> extends true ? false : true : false;
+interface CrdtDocFactory<TDoc extends any = any, TStorage extends Record<string, any> = Record<string, any>, TJson extends Record<string, any> = any, TSeed extends Record<string, any> = any> {
+  getEmpty(): CrdtDocLike<TDoc, TStorage, TJson>;
+  getFactory(seed?: TSeed): CrdtDocFactory<TDoc, TStorage, TJson, TSeed>;
+  getInitialized(seed?: TSeed): CrdtDocLike<TDoc, TStorage, TJson>;
+  isEmpty(initialStorage: Maybe<string>): boolean;
+}
+type CrdtLibraryKind = "loro" | "noop" | "yjs";
+interface CrdtLibraryType<TDoc extends CrdtDocFactory<any, any, any, any> = CrdtDocFactory<any, any>> {
+  doc: (value?: any) => TDoc;
+  kind: CrdtLibraryKind;
+}
+/** True when `TCrdt` is a real CRDT library (`yjs` / `loro`), not the noop default. */
+type HasCrdtLibrary<TCrdt> = [TCrdt] extends [never] ? false : IsAny<TCrdt> extends true ? false : [TCrdt] extends [{
+  kind: "loro" | "yjs";
+}] ? true : false;
+/** True when `TStorage` is a real doc schema/factory (`y.doc` / `loro.doc`), not the noop default. */
+type HasStorage<TStorage> = [TStorage] extends [never] ? false : [TStorage] extends [undefined] ? false : IsAny<TStorage> extends true ? false : [TStorage] extends [{
+  kind: "loro.doc" | "y.doc";
+  getEmpty: (...args: any[]) => any;
+}] ? true : false;
+interface DocApplyEncodedStateParams {
+  origin?: string;
+  update?: Maybe<string | Uint8Array>;
+}
+interface DocBatchApplyEncodedStateParams {
+  origin?: string;
+  updates?: Maybe<readonly Maybe<string | Uint8Array>[]>;
+}
+interface DocSubscribeCallbackParams<TDoc extends any = any, TStorage extends Record<string, any> = Record<string, any>, TJson extends Record<string, any> = any> {
+  doc: CrdtDocLike<TDoc, TStorage, TJson>;
+  local: boolean;
+  origin?: string | null;
+  update: string;
+}
+interface CrdtDocLike<TDoc extends any = any, TStorage extends Record<string, any> = Record<string, any>, TJson extends Record<string, any> = any> {
+  value: TDoc;
+  applyEncodedState(params: DocApplyEncodedStateParams): this;
+  batchApplyEncodedState(params: DocBatchApplyEncodedStateParams): this;
+  canRedo(): boolean;
+  canUndo(): boolean;
+  destroy(): void;
+  get(key?: undefined): TStorage;
+  get<TKey extends keyof TStorage>(key: TKey): TStorage[TKey];
+  /**
+   * @description Run `fn` and return only the changes it made. Returns `null` when `fn`
+   * does not change the document.
+   */
+  captureUpdate(fn: () => void): string | null;
+  /**
+   * @description The changes this document has that another copy is missing.
+   * `stateVector` is that copy's `getStateVector()` result. An empty string means the
+   * other copy has nothing, so this returns every change.
+   */
+  encodeDiff(stateVector: string): string;
+  getEncodedState(): string;
+  /**
+   * @description Gets which changes this document already contains. Another copy passes
+   * the result to `encodeDiff` to learn what it is missing.
+   */
+  getStateVector(): string;
+  /**
+   * @description Clocks in a `getStateVector()` value. Each clock is the next
+   * change that client would write.
+   */
+  readStateVersion(encoded: string): readonly (readonly [string, number])[];
+  /**
+   * @description Clocks carried by an update. Computed once, when those bytes arrive.
+   */
+  readUpdateVersion(update: string): readonly (readonly [string, number])[];
+  /**
+   * @description Whether this document already contains `update`, including deletes.
+   * The clocks already say it is covered.
+   */
+  containsUpdate(update: string): boolean;
+  /**
+   * @description Whether a received change is waiting because an earlier change has not
+   * arrived yet.
+   */
+  hasPending(): boolean;
+  /**
+   * @description Whether `hasPending()` can tell that a change is waiting. When this is
+   * false, ask for the whole document instead of a diff.
+   */
+  canDetectPending(): boolean;
+  /**
+   * @description Whether the document has ever received an operation. Not the inverse of
+   * `isEmpty()`: a document whose content was deleted is still dirty.
+   */
+  isDirty(): boolean;
+  isEmpty(): boolean;
+  rebuildStorage(reference?: TStorage): this;
+  redo(): this;
+  subscribe(listener: (params: DocSubscribeCallbackParams<TDoc, TStorage, TJson>) => void): () => void;
+  toJson(): TJson;
+  toJson<TKey extends keyof TJson>(type: TKey): TJson[TKey];
+  track(): this;
+  transact(fn: () => void, origin?: string): this;
+  undo(): this;
+}
+type BaseUser = {
+  id: string;
+};
+type ParticipantRef = {
+  kind: ParticipantKind;
+  operator: OperatorUser | null;
+};
+type ParticipantRecord<TUser extends BaseUser> = ParticipantRef & {
+  data: Id<TUser>;
+};
+type PresenceSeq = {
+  presence: number | null;
+};
+interface SessionPresence<TPresence extends JsonObject | null = JsonObject | null> extends ParticipantRef {
+  presence: TPresence;
+  seq: PresenceSeq;
+}
+type KindStats = {
+  connectionCount: number;
+  userCount: number;
+};
+type RoomStatsByKind = { [Kind in ParticipantKind]: KindStats; };
+type ListUsersCursor = {
+  kind: ParticipantKind;
+  id: string;
+};
+type RoomError = {
+  message: string;
+  stack?: string | null;
+};
+interface BaseClientEventRecord {
+  $getOthers: {};
+  $initializeSession: {
+    presence: JsonObject | null;
+    stateVector?: string | null;
+    update: string | null;
+  };
+  $listUsers: {
+    cursor?: ListUsersCursor | null;
+    kinds?: readonly ParticipantKind[];
+    limit?: number;
+    requestId: string;
+  };
+  $ping: {};
+  $updatePresence: {
+    presence: JsonObject | null;
+    procedure?: string | null;
+  };
+  $syncStorage: {
+    /**
+     * @description This client's `getStateVector()`. An empty string asks for the whole
+     * document.
+     */
+    stateVector: string;
+  };
+  $updateStorage: {
+    origin: string | null;
+    /**
+     * @description This update is the reply to `$storageResync`. The server does not ask
+     * again when the reply leaves the document unchanged.
+     */
+    resync?: boolean | null;
+    update: string | null;
+    procedure?: string | null;
+  };
+}
+type BaseClientMessage = InferEventMessage<BaseClientEventRecord>;
+type BaseIOEventRecord<TAuthorize extends IOAuthorize<any>> = {
+  $error: RoomError;
+  $exit: {
+    sessionId: string;
+    user: Id<InferIOAuthorizeUser<TAuthorize>>;
+    operator: OperatorUser | null;
+  };
+  $othersReceived: {
+    myConnectionIds: string[];
+    others: {
+      connectionIds: string[];
+      data: Id<InferIOAuthorizeUser<TAuthorize>>;
+      session: SessionPresence<JsonObject | null>;
+    }[];
+  };
+  $pong: {};
+  $roomStats: RoomStatsByKind;
+  $presenceUpdated: {
+    user: Id<InferIOAuthorizeUser<TAuthorize>>;
+    session: SessionPresence<JsonObject>;
+  };
+  $registered: {
+    sessionId: string;
+    state: string | null;
+    stats: RoomStatsByKind;
+    session: SessionPresence<JsonObject | null>;
+  };
+  $storageReceived: {
+    changeKind: "empty" | "initialized" | "unchanged";
+    state: string;
+  };
+  $storageDiff: {
+    update: string;
+  };
+  $storageResync: {
+    /**
+     * @description The server's `getStateVector()`. The caller who sent the update replies
+     * with `encodeDiff` of this, because the server could not integrate that update.
+     */
+    stateVector: string;
+  };
+  $storageUpdated: {
+    /**
+     * @description Bytes to merge into the local document. The changes the server integrated.
+     */
+    state: string;
+  };
+  $syncStateReceived: {
+    connectionIds: readonly string[];
+  };
+  $userJoined: {
+    connectionId: string;
+    user: Id<InferIOAuthorizeUser<TAuthorize>>;
+    session: SessionPresence<JsonObject>;
+  };
+  $usersPage: {
+    requestId: string;
+    success: true;
+    pageInfo: {
+      endCursor: ListUsersCursor | null;
+      hasNextPage: boolean;
+    };
+    users: ParticipantRecord<InferIOAuthorizeUser<TAuthorize>>[];
+  } | {
+    requestId: string;
+    success: false;
+    error: {
+      code: "FAILED" | "INVALID_LIMIT";
+      message: string;
+    };
+  };
+};
+interface EventMessage<TEvent extends string, TData extends JsonObject = {}> {
+  data: TData;
+  type: TEvent;
+}
+type EventRecord<TEvent extends string, TData extends JsonObject> = { [key in `${TEvent}`]: TData; };
+type GetEventMessage<T extends EventRecord<string, any>, TEvent extends keyof T> = TEvent extends string ? EventMessage<TEvent, T[TEvent]> : never;
+type InferStandardSchemaOutput<TSchema> = TSchema extends StandardSchemaV1$1<any, infer TOutput> ? TOutput : never;
+type TreatyProcedureKind = "presence" | "storage";
+type TreatyProcedureLike<TKind extends TreatyProcedureKind = TreatyProcedureKind, TInput extends Record<string, any> = Record<string, any>> = {
+  kind: TKind;
+  readonly prepared?: boolean;
+  config: {
+    input?: StandardSchemaV1$1<unknown, TInput> | null;
+    prepare?: ((data: never, ...args: any[]) => unknown) | null;
+    resolve?: ((data: never, ...args: any[]) => unknown) | null;
+    transact?: boolean | null;
+  };
+  apply: (data: unknown, context: any, prepared?: unknown) => unknown;
+  load?: (data: unknown, context: any) => Promise<{
+    input: unknown;
+    prepared: unknown;
+  }>;
+};
+type InferTreatyProcedureInput<TProcedure extends TreatyProcedureLike<any, any>> = TProcedure extends TreatyProcedureLike<any, infer TInput> ? Id<TInput> : never;
+type InferTreatyPresenceProcedures<TTreaty extends TreatyLike | undefined> = TTreaty extends TreatyLike ? TTreaty["_defs"]["procedures"]["presence"] : {};
+type InferTreatyStorageProcedures<TTreaty extends TreatyLike | undefined> = TTreaty extends TreatyLike ? TTreaty["_defs"]["procedures"]["storage"] : {};
+type TreatyProcedureInputJson = {
+  input: unknown;
+};
+type TreatyProcedureInputsJson<TProcedures extends Record<string, TreatyProcedureLike>> = { [K in keyof TProcedures]: TreatyProcedureInputJson; };
+type TreatyProceduresJson<TPresence extends Record<string, TreatyProcedureLike> = Record<string, TreatyProcedureLike<"presence">>, TStorage extends Record<string, TreatyProcedureLike> = Record<string, TreatyProcedureLike<"storage">>> = {
+  presence: TreatyProcedureInputsJson<TPresence>;
+  storage: TreatyProcedureInputsJson<TStorage>;
+};
+interface TreatyLike {
+  user: StandardSchemaV1$1<unknown, BaseUser>;
+  presence?: StandardSchemaV1$1<any, any> | undefined;
+  storage?: CrdtDocFactory<any, any, any, any> | undefined;
+  toUserJson(): unknown;
+  toPresenceJson(): unknown;
+  toStorageJson(): unknown;
+  toProceduresJson(): TreatyProceduresJson<this["_defs"]["procedures"]["presence"], this["_defs"]["procedures"]["storage"]>;
+  _defs: {
+    user: StandardSchemaV1$1<unknown, BaseUser>;
+    presence: StandardSchemaV1$1<any, any> | undefined;
+    storage: CrdtDocFactory<any, any, any, any> | undefined;
+    procedures: {
+      presence: Record<string, TreatyProcedureLike<"presence">>;
+      storage: Record<string, TreatyProcedureLike<"storage">>;
+    };
+  };
+}
+type InferTreatyUser<TTreaty extends TreatyLike | undefined> = TTreaty extends TreatyLike ? InferIOAuthorizeUser<{
+  user: TTreaty["user"];
+}> : BaseUser;
+type InferTreatyPresence<TTreaty extends TreatyLike | undefined> = TTreaty extends TreatyLike ? InferStandardSchemaOutput<TTreaty["presence"]> : never;
+type InferTreatyStorage<TTreaty extends TreatyLike | undefined> = TTreaty extends TreatyLike ? TTreaty["storage"] : undefined;
+type InferIOAuthorize<TIO extends IOLike> = TIO extends IOLike<infer D> ? IsAny<D> extends true ? {
+  user: StandardSchemaV1$1<unknown, any>;
+} : {
+  user: D["treaty"]["user"];
+} : never;
+type InferIOAuthorizeUser<TAuthorize> = IsAny<TAuthorize> extends true ? any : TAuthorize extends {
+  user: infer TUserSchema;
+} ? InferStandardSchemaOutput<TUserSchema> extends (infer TUser extends BaseUser) ? TUser : BaseUser : never;
+type IOAuthorize<TUser extends BaseUser = any> = {
+  secret?: string;
+  user: StandardSchemaV1$1<unknown, TUser>;
+};
+type IOAuthorizeEventMessage<TIO extends IOLike> = {
+  connectionId: string;
+  user: InferIOAuthorizeUser<InferIOAuthorize<TIO>>;
+  operator: OperatorUser | null;
+};
+type ProcedureLike<TInput extends Record<string, any> = {}, TOutput extends EventRecord<string, any> = {}> = {
+  config: {
+    broadcast?: ((data: TInput, ...args: any[]) => MaybePromise<Partial<TOutput> | void>) | null;
+    input?: StandardSchemaV1$1<unknown, TInput> | null;
+    self?: ((data: TInput, ...args: any[]) => MaybePromise<Partial<TOutput> | void>) | null;
+  };
+};
+interface IORouterLike<TEvents extends Record<string, ProcedureLike<any, any>> = {}> {
+  _defs: {
+    events: TEvents;
+  };
+}
+type IOLikeDefs = {
+  treaty: TreatyLike;
+  events: Record<string, ProcedureLike<any, any>>;
+};
+interface IOLike<T extends IOLikeDefs = any> extends IORouterLike<T["events"]> {
+  _defs: T;
+}
+type InferIOCrdtKind<TIO extends IOLike> = InferIOStorage<TIO>;
+type InferIOCrdt<TIO extends IOLike> = InferIOStorage<TIO>;
+type InferIOStorage<TIO extends IOLike> = TIO extends IOLike<infer D> ? (IsAny<D> extends true ? any : D["treaty"]["storage"]) : never;
+type InferIOTreaty<TIO extends IOLike> = TIO extends IOLike<infer D> ? (IsAny<D> extends true ? TreatyLike : D["treaty"]) : TreatyLike;
+type InferIOEvents<TIO extends IOLike> = TIO extends IOLike<infer D> ? IsAny<D> extends true ? any : { [P in keyof D["events"]]: ProcedureLike<InferIOProcedureInput<D["events"][P]>, InferIOProcedureOutput<D["events"][P]>>; } : never;
+type InferIOProcedureInput<TProcedure extends ProcedureLike<any, any>> = TProcedure extends ProcedureLike<infer IInput, any> ? Id<IInput> : never;
+type InferIOProcedureOutput<TProcedure extends ProcedureLike<any, any>> = TProcedure extends ProcedureLike<any, infer IOutput> ? Id<IOutput> : never;
+type InferEventsInput<TEvents extends Record<string, ProcedureLike<any, any>>> = { [P in keyof TEvents]: TEvents[P] extends ProcedureLike<infer IInput, any> ? Id<IInput> : never; };
+type InferEventsOutput<TEvents extends Record<string, ProcedureLike<any, any>>> = UnionToIntersection<{ [P in keyof TEvents]: TEvents[P] extends ProcedureLike<any, infer IOutput> ? Id<IOutput> : never; }[keyof TEvents]>;
+type InferIOInput<TRouter extends IORouterLike<any>> = TRouter extends IORouterLike<infer IEvents> ? InferEventsInput<IEvents> : never;
+type InferIOOutput<TRouter extends IORouterLike<any>> = TRouter extends IORouterLike<infer IEvents> ? InferEventsOutput<IEvents> : never;
+type InferEventMessage<TEvents = EventRecord<string, any>, TEvent extends keyof TEvents = keyof TEvents> = TEvents extends EventRecord<string, any> ? { [P in TEvent]: P extends string ? Id<EventMessage<P, TEvents[P]>> : never; }[TEvent] : never;
+type ServerOriginEvent = "$error" | "$roomStats" | "$syncStateReceived";
+type IOEventMessage<TIO extends IOLike, TEvent extends keyof InferIOOutput<TIO> = keyof InferIOOutput<TIO>> = Id<{
+  room: string;
+} & InferEventMessage<InferIOOutput<TIO>, TEvent> & (InferEventMessage<InferIOOutput<TIO>, TEvent>["type"] extends ServerOriginEvent ? {
+  connectionId?: string | null;
+  user?: InferIOAuthorizeUser<InferIOAuthorize<TIO>> | null;
+  operator?: OperatorUser | null;
+} : IOAuthorizeEventMessage<TIO>)>;
+type ParticipantKind = "user" | "operator";
+type OperatorUser = {
+  id: string;
+  name: string;
+  imageUrl: string | null;
+};
+type OnGetOperator<TUser extends BaseUser = BaseUser> = (params: {
+  operator: OperatorUser & {
+    email: string;
+  };
+  room: string;
+}) => MaybePromise<TUser | null>;
+type ParticipantKindOptions = {
+  kind?: ParticipantKind;
+};
+type ParticipantKindsOptions = {
+  kinds?: readonly ParticipantKind[];
+};
+export declare const ConnectionState: {
+  readonly Closed: "closed";
+  readonly Connecting: "connecting";
+  readonly Open: "open";
+  readonly Unavailable: "unavailable";
+  readonly Untouched: "untouched";
+};
+export type ConnectionState = (typeof ConnectionState)[keyof typeof ConnectionState];
+export declare const StorageState: {
+  Loading: string;
+  Offline: string;
+  Synced: string;
+  Unavailable: string;
+};
+export type StorageState = (typeof StorageState)[keyof typeof StorageState];
+interface AuthorizationState<TIO extends IOLike> {
+  token: string | null;
+  user: Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>> | null;
+  kind: ParticipantKind;
+  operator: OperatorUser | null;
+}
+type OtherSubscriptionCallback<TIO extends IOLike, TPresence extends Record<string, any>> = (value: Id<UserInfo<TIO, TPresence>> | null) => void;
+type OtherSubscriptionFn<TIO extends IOLike, TPresence extends Record<string, any>> = (userId: string, callback: OtherSubscriptionCallback<TIO, TPresence>, options?: ParticipantKindOptions) => () => void;
+type OthersSubscriptionEvent<TIO extends IOLike, TPresence extends Record<string, any>> = {
+  kind: "clear";
+} | {
+  kind: "enter";
+  user: Id<UserInfo<TIO, TPresence>>;
+} | {
+  kind: "leave";
+  user: Id<UserInfo<TIO, TPresence>>;
+} | {
+  kind: "sync";
+  users: readonly Id<UserInfo<TIO, TPresence>>[];
+} | {
+  kind: "update";
+  user: Id<UserInfo<TIO, TPresence>>;
+};
+type OthersSubscriptionCallback<TIO extends IOLike, TPresence extends Record<string, any>> = (value: readonly Id<UserInfo<TIO, TPresence>>[], event: OthersSubscriptionEvent<TIO, TPresence>) => void;
+type OthersSubscriptionFn<TIO extends IOLike, TPresence extends Record<string, any>> = (callback: OthersSubscriptionCallback<TIO, TPresence>, options?: ParticipantKindsOptions) => () => void;
+interface StateNotifierSubjects<TIO extends IOLike, TPresence extends Record<string, any>> {
+  connection: Subject<Id<WebSocketState<TIO>>>;
+  "my-presence": Subject<TPresence | null>;
+  myself: Subject<Readonly<Id<UserInfo<TIO, TPresence>>> | null>;
+  others: Subject<readonly Id<UserInfo<TIO, TPresence>>[]>;
+  roomStats: Subject<RoomStats>;
+  "storage-loaded": Subject<boolean>;
+}
+type InferSubjectValue<TIO extends IOLike, TPresence extends Record<string, any>, TSubject extends keyof StateNotifierSubjects<TIO, TPresence>> = StateNotifierSubjects<TIO, TPresence>[TSubject] extends Subject<infer IValue> ? Id<IValue> : never;
+type SubscriptionCallback<TIO extends IOLike, TPresence extends Record<string, any>, TSubject extends keyof StateNotifierSubjects<TIO, TPresence>> = (value: InferSubjectValue<TIO, TPresence, TSubject>) => void;
+type UpdateMyPresenceAction<TPresence extends Record<string, any>> = Partial<TPresence> | ((oldPresence: TPresence | null) => Partial<TPresence>);
+interface UserRecord<TIO extends IOLike> {
+  data: Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>>;
+}
+interface UserInfo<TIO extends IOLike, TPresence extends Record<string, any> = {}> extends UserRecord<TIO> {
+  presence: TPresence;
+  kind: ParticipantKind;
+  operator: OperatorUser | null;
+}
+type RoomStats = KindStats;
+type RoomErrorSubscriptionCallback = (error: RoomError) => void;
+type RoomErrorSubscriptionFn = (callback: RoomErrorSubscriptionCallback) => () => void;
+type ListUsersOptions = {
+  cursor?: ListUsersCursor | null;
+  kinds?: readonly ParticipantKind[];
+  limit?: number;
+};
+type ListUsersRow<TIO extends IOLike> = ParticipantRecord<InferIOAuthorizeUser<InferIOAuthorize<TIO>>>;
+type UsersPage<TIO extends IOLike> = {
+  pageInfo: {
+    endCursor: ListUsersCursor | null;
+    hasNextPage: boolean;
+  };
+  users: ListUsersRow<TIO>[];
+};
+type ListUsersErrorCode = "FAILED" | "INVALID_LIMIT" | "NOT_CONNECTED";
+type ListUsersError = {
+  code: ListUsersErrorCode;
+  message: string;
+};
+type ListUsersResult<TIO extends IOLike> = {
+  success: true;
+  pageInfo: UsersPage<TIO>["pageInfo"];
+  users: UsersPage<TIO>["users"];
+} | {
+  success: false;
+  error: ListUsersError;
+};
+interface WebSocketConnection {
+  /**
+   * @description How many times a connection attempt was made. This will increment upon each
+   * unsuccessful attempt, and will reset upon a successful connection.
+   * @date April 13, 2025
+   */
+  attempts: number;
+  id: string | null;
+  state: ConnectionState;
+}
+interface StorageInfo {
+  state: StorageState;
+}
+interface WebSocketState<TIO extends IOLike> {
+  authorization: AuthorizationState<TIO>;
+  connection: WebSocketConnection;
+  storage: StorageInfo;
+  webSocket: WebSocket | null;
+}
+type BroadcastProxy<TIO extends IOLike> = (<TEvent extends keyof InferIOInput<TIO>>(event: TEvent, data: Id<InferIOInput<TIO>[TEvent]>) => Promise<void>) & { [PEvent in keyof InferIOInput<TIO>]: (data: Id<InferIOInput<TIO>[PEvent]>) => Promise<void>; };
+type PresenceProcedureProxy<TProcedures extends Record<string, TreatyProcedureLike<"presence">> = {}> = (<TName extends Extract<keyof TProcedures, string>>(name: TName, data: InferTreatyProcedureInput<TProcedures[TName]>) => Promise<void>) & { [TName in Extract<keyof TProcedures, string>]: (data: InferTreatyProcedureInput<TProcedures[TName]>) => Promise<void>; };
+type StorageProcedureProxy<TProcedures extends Record<string, TreatyProcedureLike<"storage">> = {}> = (<TName extends Extract<keyof TProcedures, string>>(name: TName, data: InferTreatyProcedureInput<TProcedures[TName]>) => void) & { [TName in Extract<keyof TProcedures, string>]: (data: InferTreatyProcedureInput<TProcedures[TName]>) => void; };
+type PublicEventKey<TEvents> = Exclude<Extract<keyof TEvents, string>, `$${string}`>;
+type EventNotifierSubscriptionCallback<TIO extends IOLike, TEvent extends keyof InferIOOutput<TIO>> = (value: Id<IOEventMessage<TIO, TEvent>>) => void;
+type EventSubscriptionFn<TIO extends IOLike> = <TEvent extends PublicEventKey<InferIOOutput<TIO>>>(event: TEvent, callback: EventNotifierSubscriptionCallback<TIO, TEvent>) => () => void;
+type EventProxy<TIO extends IOLike> = EventSubscriptionFn<TIO> & { [PEvent in PublicEventKey<InferIOOutput<TIO>>]: (callback: EventNotifierSubscriptionCallback<TIO, PEvent>) => () => void; };
+type StorageSubscriptionCallback<TJson extends Record<string, any>, TKey extends keyof TJson> = (value: TJson[TKey]) => void;
+type StorageSubscriptionFn<TJson extends Record<string, any>> = <TKey extends keyof TJson>(key: TKey, fn: StorageSubscriptionCallback<TJson, TKey>) => () => void;
+type StorageRootSubscriptionCallback<TJson extends Record<string, any>> = (value: TJson) => void;
+type StorageRootSubscriptionFn<TJson extends Record<string, any>> = (callback: StorageRootSubscriptionCallback<TJson>) => () => void;
+type StorageProxy<TJson extends Record<string, any>> = StorageSubscriptionFn<TJson> & StorageRootSubscriptionFn<TJson> & { [PKey in keyof TJson]: (callback: StorageSubscriptionCallback<TJson, PKey>) => () => void; };
+type SubscribeFn<TValue extends unknown> = (callback: (value: TValue) => void) => () => void;
+type SubscribeProxy<TIO extends IOLike, TPresence extends Record<string, any>, TJson extends Record<string, any>> = (<TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(name: TSubject, callback: SubscriptionCallback<TIO, TPresence, TSubject>) => () => void) & {
+  connection: SubscribeFn<Id<WebSocketState<TIO>>>;
+  error: RoomErrorSubscriptionFn;
+  event: EventProxy<TIO>;
+  myPresence: SubscribeFn<TPresence | null>;
+  myself: SubscribeFn<Id<UserInfo<TIO>> | null>;
+  other: OtherSubscriptionFn<TIO, TPresence>;
+  others: OthersSubscriptionFn<TIO, TPresence>;
+  roomStats: SubscribeFn<RoomStats>;
+  storage: StorageProxy<TJson>;
+  storageLoaded: SubscribeFn<boolean>;
+};
+interface RoomEventListenerMap {
+  close: (event: CloseEvent | null) => void;
+  error: (event: Event) => void;
+  message: (event: MessageEvent<any>) => void;
+  open: (event: Event) => void;
+}
+interface RoomLike<TIO extends IOLike, TDoc extends any, TPresence extends Record<string, any> = {}, TStorage extends Record<string, any> = {}, TJson extends Record<string, any> = any, TTreaty extends TreatyLike = TreatyLike> {
+  id: string;
+  broadcast: BroadcastProxy<TIO>;
+  presence: PresenceProcedureProxy<TTreaty["_defs"]["procedures"]["presence"]>;
+  storage: StorageProcedureProxy<TTreaty["_defs"]["procedures"]["storage"]>;
+  addEventListener<TKind extends keyof RoomEventListenerMap>(kind: TKind, handler: RoomEventListenerMap[TKind]): () => void;
+  canRedo(): boolean;
+  canUndo(): boolean;
+  getDoc(): CrdtDocLike<TDoc, TStorage, TJson>;
+  getConnection(): WebSocketConnection;
+  getMyPresence(): TPresence;
+  getMyself(): Id<UserInfo<TIO, TPresence>> | null;
+  getOther(userId: string, options?: ParticipantKindOptions): Id<UserInfo<TIO, TPresence>> | null;
+  getOtherByConnectionId(connectionId: string, options?: ParticipantKindsOptions): Id<UserInfo<TIO, TPresence>> | null;
+  getOthers(options?: ParticipantKindsOptions): readonly Id<UserInfo<TIO, TPresence>>[];
+  getRoomStats(options?: ParticipantKindsOptions): RoomStats;
+  getStorage<TKey extends keyof TStorage>(type: TKey): TStorage[TKey] | null;
+  getStorageJson(): TJson | null;
+  getStorageJson<TKey extends keyof TJson>(type: TKey): TJson[TKey] | null;
+  getStorageLoaded: () => boolean;
+  listUsers(options?: ListUsersOptions): Promise<ListUsersResult<TIO>>;
+  redo(): void;
+  subscribe: SubscribeProxy<TIO, TPresence, TJson>;
+  transact(fn: (storage: TStorage) => void, origin?: string): void;
+  undo(): void;
+  updateMyPresence(presence: UpdateMyPresenceAction<TPresence>): void;
+}
+export type { AreAllOptional, BaseClientEventRecord, BaseClientMessage, BaseIOEventRecord, BaseUser, BroadcastProxy, Constructable, CrdtDocFactory, CrdtDocLike, CrdtLibraryKind, CrdtLibraryType, DeepPartial, DeepReadonly, DeepWriteable, DocApplyEncodedStateParams, DocBatchApplyEncodedStateParams, DocSubscribeCallbackParams, EventMessage, EventNotifierSubscriptionCallback, EventProxy, EventRecord, GetEventMessage, HasCrdtLibrary, HasRequiredProperty, HasStorage, IOAuthorize, IOAuthorizeEventMessage, IOEventMessage, IOLike, IOLikeDefs, IORouterLike, Id, InferEventMessage, InferEventsInput, InferEventsOutput, InferIOAuthorize, InferIOAuthorizeUser, InferIOCrdt, InferIOCrdtKind, InferIOEvents, InferIOInput, InferIOOutput, InferIOProcedureInput, InferIOProcedureOutput, InferIOStorage, InferIOTreaty, InferTreatyPresence, InferTreatyPresenceProcedures, InferTreatyProcedureInput, InferTreatyStorage, InferTreatyStorageProcedures, InferTreatyUser, IsAny, Json, JsonObject, JsonPrimitive, KindStats, ListUsersCursor, ListUsersError, ListUsersErrorCode, ListUsersOptions, ListUsersResult, ListUsersRow, Maybe, MaybePromise, MaybeReadonlyArray, NonNilProps, OnGetOperator, OperatorUser, OptionalProps, OtherSubscriptionCallback, OtherSubscriptionFn, OthersSubscriptionCallback, OthersSubscriptionEvent, OthersSubscriptionFn, ParticipantKind, ParticipantKindOptions, ParticipantKindsOptions, ParticipantRecord, ParticipantRef, PresenceProcedureProxy, PresenceSeq, ProcedureLike, PublicEventKey, RoomError, RoomErrorSubscriptionCallback, RoomErrorSubscriptionFn, RoomEventListenerMap, RoomLike, RoomStats, RoomStatsByKind, ServerOriginEvent, SessionPresence, SetKey, Spread, SpreadProperties, StandardSchemaV1, StateNotifierSubjects, StorageInfo, StorageProcedureProxy, StorageProxy, StorageRootSubscriptionCallback, StorageRootSubscriptionFn, StorageSubscriptionCallback, StorageSubscriptionFn, SubscribeFn, SubscribeProxy, SubscriptionCallback, TreatyLike, TreatyProcedureInputJson, TreatyProcedureInputsJson, TreatyProcedureKind, TreatyProcedureLike, TreatyProceduresJson, UndefinedProps, UpdateMyPresenceAction, UserInfo, UserRecord, UsersPage, WebSocketConnection, WebSocketState };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":["StandardSchemaV1"],"sources":["../src/general.ts","../src/pluv/crdt.ts","../src/pluv/shared.ts","../src/pluv/operator.ts","../src/pluv/enums.ts","../src/pluv/room.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -0,0 +1,17 @@
+// src/pluv/enums.ts
+const ConnectionState = {
+	Closed: "closed",
+	Connecting: "connecting",
+	Open: "open",
+	Unavailable: "unavailable",
+	Untouched: "untouched"
+};
+const StorageState = {
+	Loading: "loading",
+	Offline: "offline",
+	Synced: "synced",
+	Unavailable: "unavailable"
+};
+export { ConnectionState, StorageState };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/pluv/enums.ts"],"sourcesContent":["export const ConnectionState = {\n    Closed: \"closed\",\n    Connecting: \"connecting\",\n    Open: \"open\",\n    Unavailable: \"unavailable\",\n    Untouched: \"untouched\",\n} as const;\n\nexport type ConnectionState = (typeof ConnectionState)[keyof typeof ConnectionState];\n\nexport const StorageState = {\n    Loading: \"loading\",\n    Offline: \"offline\",\n    Synced: \"synced\",\n    Unavailable: \"unavailable\",\n};\n\nexport type StorageState = (typeof StorageState)[keyof typeof StorageState];\n"],"mappings":";AAAA,MAAa,kBAAkB;CAC3B,QAAQ;CACR,YAAY;CACZ,MAAM;CACN,aAAa;CACb,WAAW;AACf;AAIA,MAAa,eAAe;CACxB,SAAS;CACT,SAAS;CACT,QAAQ;CACR,aAAa;AACjB"}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@pluv/types",
+  "version": "0.0.0-canary-20261026091827",
+  "description": "@pluv/io shared types",
+  "author": {
+    "email": "david@pluv.io",
+    "name": "i3dly",
+    "url": "https://github.com/i3dly"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/pluv-io/pluv",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pluv-io/pluv.git",
+    "directory": "packages/types"
+  },
+  "type": "module",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@pluv/tsconfig": "^0.0.0-canary-20261026091827",
+    "tsdown": "^0.23.2",
+    "typescript": "7.1.0-beta"
+  },
+  "dependencies": {
+    "@standard-schema/spec": "^1.1.0",
+    "wonka": "^6.3.6"
+  },
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./*": "./*"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+  }
+}