import { StandardSchemaV1 } from "@standard-schema/spec";
import { Patch } from "immer";

//#region src/domain/wrpcSchema.d.ts
type Maybe<T> = T | unknown;
type MaybePromise<T> = T | Promise<T>;
type Shape<Input = unknown, Output = unknown> = StandardSchemaV1<Input, Output>;
type InferShapeInput<S extends Maybe<Shape>, Fallback = unknown> = S extends Shape<infer I, unknown> ? I : Fallback;
type InferShapeOutput<S extends Maybe<Shape>, Fallback = unknown> = S extends Shape<unknown, infer O> ? O : Fallback;
type MaybeShapeArgs<S extends Maybe<Shape>> = S extends Shape ? [input: InferShapeInput<S>] : [];
type MaybeShapeListener<S extends Maybe<Shape>> = S extends Shape ? (input: InferShapeOutput<S>) => void : () => void;
interface ShapeValidResult {
  valid: true;
  data: unknown;
}
interface ShapeInvalidResult {
  valid: false;
  issues: readonly StandardSchemaV1.Issue[];
}
type ShapeValidateResult = ShapeValidResult | ShapeInvalidResult;
declare const validateShape: (shape?: Maybe<Shape>, data?: unknown) => Promise<ShapeValidateResult>;
//#endregion
//#region src/domain/wrpcRoomBroadcast.d.ts
type WrpcRoomBroadcastData<Input extends Maybe<Shape> = unknown> = {
  input?: Input;
};
type WrpcRoomBroadcastDefinition<Input extends Maybe<Shape> = unknown> = {
  input: Input extends Shape ? Input : undefined;
};
type WrpcRoomBroadcast<Input extends Maybe<Shape> = unknown> = WrpcRoomBroadcastDefinition<Input>;
type WrpcRoomBroadcasts<Broadcasts extends Maybe<Record<string, WrpcRoomBroadcast>> = unknown> = Broadcasts extends Record<string, WrpcRoomBroadcast> ? {
  broadcasts: Broadcasts;
} : {
  broadcasts?: Broadcasts;
};
declare const defineWrpcRoomBroadcast: <Input extends Maybe<Shape> = unknown>(wrpcRoomBroadcastData: WrpcRoomBroadcastData<Input>) => WrpcRoomBroadcast<Input>;
//#endregion
//#region src/domain/wrpcRoomCommand.d.ts
type WrpcRoomCommandData<Input extends Maybe<Shape> = unknown, Output extends Maybe<Shape> = unknown> = {
  input?: Input;
  output?: Output;
};
type WrpcRoomCommandDefinition<Input extends Maybe<Shape> = unknown, Output extends Maybe<Shape> = unknown> = {
  input: Input extends Shape ? Input : undefined;
  output: Output extends Shape ? Output : undefined;
};
type WrpcRoomCommand<Input extends Maybe<Shape> = unknown, Output extends Maybe<Shape> = unknown> = WrpcRoomCommandDefinition<Input, Output>;
type WrpcRoomCommands<Commands extends Maybe<Record<string, WrpcRoomCommand>> = unknown> = Commands extends Record<string, WrpcRoomCommand> ? {
  commands: Commands;
} : {
  commands?: Commands;
};
declare const defineWrpcRoomCommand: <Input extends Maybe<Shape> = unknown, Output extends Maybe<Shape> = unknown>(wrpcRoomCommandData: WrpcRoomCommandData<Input, Output>) => WrpcRoomCommand<Input, Output>;
//#endregion
//#region src/domain/wrpcRoomConnectionMetadata.d.ts
type WrpcRoomConnectionMetadata<ConnectionMetadata extends Maybe<Shape> = unknown> = ConnectionMetadata extends Shape ? {
  connectionMetadata: ConnectionMetadata;
  initialConnectionMetadata: InferShapeOutput<ConnectionMetadata>;
} : {
  connectionMetadata?: ConnectionMetadata;
  initialConnectionMetadata?: InferShapeOutput<ConnectionMetadata>;
};
//#endregion
//#region src/domain/wrpcRoomError.d.ts
type WrpcRoomErrors<Errors extends Maybe<Record<string, Maybe<Shape>>> = unknown> = {
  errors?: Errors;
};
//#endregion
//#region src/domain/wrpcRoomEvent.d.ts
type WrpcRoomEventData<Input extends Maybe<Shape> = unknown> = {
  input?: Input;
};
type WrpcRoomEventDefinition<Input extends Maybe<Shape> = unknown> = {
  input: Input extends Shape ? Input : undefined;
};
type WrpcRoomEvent<Input extends Maybe<Shape> = unknown> = WrpcRoomEventDefinition<Input>;
type WrpcRoomEvents<Events extends Maybe<Record<string, WrpcRoomEvent>> = unknown> = Events extends Record<string, WrpcRoomEvent> ? {
  events: Events;
} : {
  events?: Events;
};
declare const defineWrpcRoomEvent: <Input extends Maybe<Shape> = unknown>(wrpcRoomEventData: WrpcRoomEventData<Input>) => WrpcRoomEvent<Input>;
//#endregion
//#region src/domain/wrpcRoomLifecycle.d.ts
type WrpcRoomLifecycles<Create extends Maybe<Shape>, Join extends Maybe<Shape>> = {
  create?: Create;
  join?: Join;
};
//#endregion
//#region src/domain/wrpcRoomMetadata.d.ts
type WrpcRoomMetadata<Metadata extends Maybe<Shape> = unknown> = Metadata extends Shape ? {
  metadata: Metadata;
  initialMetadata: InferShapeOutput<Metadata>;
} : {
  metadata?: Metadata;
  initialMetadata?: InferShapeOutput<Metadata>;
};
//#endregion
//#region src/domain/wrpcRoomSettings.d.ts
type WrpcRoomConfig = {
  maxConnections?: number;
  locked?: boolean;
};
type WrpcRoomSettings = {
  config?: WrpcRoomConfig;
};
//#endregion
//#region src/domain/wrpcRoomState.d.ts
type WrpcRoomState<State extends Maybe<Shape> = unknown> = State extends Shape ? {
  state: State;
  initialState: InferShapeOutput<State>;
} : {
  state?: State;
  initialState?: InferShapeOutput<State>;
};
//#endregion
//#region src/domain/wrpcRoom.d.ts
type WrpcRoomData<State extends Maybe<Shape> = unknown, Metadata extends Maybe<Shape> = unknown, ConnectionMetadata extends Maybe<Shape> = unknown, Errors extends Maybe<Record<string, Maybe<Shape>>> = unknown, Create extends Maybe<Shape> = unknown, Join extends Maybe<Shape> = unknown, Broadcasts extends Maybe<Record<string, WrpcRoomBroadcast>> = unknown, Events extends Maybe<Record<string, WrpcRoomEvent>> = unknown, Commands extends Maybe<Record<string, WrpcRoomCommand>> = unknown> = WrpcRoomSettings & WrpcRoomState<State> & WrpcRoomMetadata<Metadata> & WrpcRoomConnectionMetadata<ConnectionMetadata> & WrpcRoomErrors<Errors> & WrpcRoomLifecycles<Create, Join> & WrpcRoomBroadcasts<Broadcasts> & WrpcRoomEvents<Events> & WrpcRoomCommands<Commands>;
type WrpcRoomDefinition<State extends Maybe<Shape> = unknown, Metadata extends Maybe<Shape> = unknown, ConnectionMetadata extends Maybe<Shape> = unknown, Errors extends Maybe<Record<string, Maybe<Shape>>> = unknown, Create extends Maybe<Shape> = unknown, Join extends Maybe<Shape> = unknown, Broadcasts extends Maybe<Record<string, WrpcRoomBroadcast>> = unknown, Events extends Maybe<Record<string, WrpcRoomEvent>> = unknown, Commands extends Maybe<Record<string, WrpcRoomCommand>> = unknown> = {
  config?: WrpcRoomConfig;
  state: State extends Shape ? State : undefined;
  initialState: InferShapeOutput<State, undefined>;
  metadata: Metadata extends Shape ? Metadata : undefined;
  initialMetadata: InferShapeOutput<Metadata, undefined>;
  connectionMetadata: ConnectionMetadata extends Shape ? ConnectionMetadata : undefined;
  initialConnectionMetadata: InferShapeOutput<ConnectionMetadata, undefined>;
  errors: Errors extends Record<string, Maybe<Shape>> ? Errors : Record<string, Maybe<Shape>>;
  create: Create extends Shape ? Create : undefined;
  join: Join extends Shape ? Join : undefined;
  broadcasts: Broadcasts extends Record<string, WrpcRoomBroadcast> ? Broadcasts : Record<string, WrpcRoomBroadcast>;
  events: Events extends Record<string, WrpcRoomEvent> ? Events : Record<string, WrpcRoomEvent>;
  commands: Commands extends Record<string, WrpcRoomCommand> ? Commands : Record<string, WrpcRoomCommand>;
};
type WrpcRoom<State extends Maybe<Shape> = unknown, Metadata extends Maybe<Shape> = unknown, ConnectionMetadata extends Maybe<Shape> = unknown, Errors extends Maybe<Record<string, Maybe<Shape>>> = unknown, Create extends Maybe<Shape> = unknown, Join extends Maybe<Shape> = unknown, Broadcasts extends Maybe<Record<string, WrpcRoomBroadcast>> = unknown, Events extends Maybe<Record<string, WrpcRoomEvent>> = unknown, Commands extends Maybe<Record<string, WrpcRoomCommand>> = unknown, WrpcRoomBase extends Maybe<WrpcRoom> = unknown> = WrpcRoomDefinition<State, Metadata, ConnectionMetadata, Errors, Create, Join, Broadcasts, Events, Commands> & {
  wrpcRoomBase?: WrpcRoomBase;
  extend: <NewState extends Maybe<Shape> = State, NewRoomMetadata extends Maybe<Shape> = unknown, NewConnectionMetadata extends Maybe<Shape> = unknown, NewErrors extends Maybe<Record<string, Maybe<Shape>>> = unknown, NewCreate extends Maybe<Shape> = unknown, NewJoin extends Maybe<Shape> = unknown, NewBroadcasts extends Maybe<Record<string, WrpcRoomBroadcast>> = unknown, NewEvents extends Maybe<Record<string, WrpcRoomEvent>> = unknown, NewCommands extends Maybe<Record<string, WrpcRoomCommand>> = unknown>(extender: (wrpcRoomBase: WrpcRoomDefinition<State, Metadata, ConnectionMetadata, Errors, Create, Join, Broadcasts, Events, Commands>) => WrpcRoomData<NewState, NewRoomMetadata, NewConnectionMetadata, NewErrors, NewCreate, NewJoin, NewBroadcasts, NewEvents, NewCommands>) => WrpcRoom<NewState, NewRoomMetadata, NewConnectionMetadata, NewErrors, NewCreate, NewJoin, NewBroadcasts, NewEvents, NewCommands, WrpcRoom<State, Metadata, ConnectionMetadata, Errors, Create, Join, Broadcasts, Events, Commands>>;
};
declare const defineWrpcRoom: <State extends Maybe<Shape> = unknown, Metadata extends Maybe<Shape> = unknown, ConnectionMetadata extends Maybe<Shape> = unknown, Errors extends Maybe<Record<string, Maybe<Shape>>> = unknown, Create extends Maybe<Shape> = unknown, Join extends Maybe<Shape> = unknown, Broadcasts extends Maybe<Record<string, WrpcRoomBroadcast>> = unknown, Events extends Maybe<Record<string, WrpcRoomEvent>> = unknown, Commands extends Maybe<Record<string, WrpcRoomCommand>> = unknown, WrpcRoomBase extends Maybe<WrpcRoom> = unknown>(wrpcRoomData: WrpcRoomData<State, Metadata, ConnectionMetadata, Errors, Create, Join, Broadcasts, Events, Commands>, wrpcRoomBase?: WrpcRoomBase) => WrpcRoom<State, Metadata, ConnectionMetadata, Errors, Create, Join, Broadcasts, Events, Commands, WrpcRoomBase>;
//#endregion
//#region src/domain/wrpc.d.ts
type WrpcData<WrpcRooms extends Maybe<Record<string, WrpcRoom>> = unknown> = WrpcRooms extends Record<string, WrpcRoom> ? {
  rooms: WrpcRooms;
} : {
  rooms?: WrpcRooms;
};
type WrpcDefinition<WrpcRooms extends Maybe<Record<string, WrpcRoom>> = unknown> = {
  rooms: WrpcRooms extends Record<string, WrpcRoom> ? WrpcRooms : Record<string, WrpcRoom>;
};
type Wrpc<WrpcRooms extends Maybe<Record<string, WrpcRoom>> = unknown> = WrpcDefinition<WrpcRooms>;
declare const defineWrpc: <WrpcRooms extends Maybe<Record<string, WrpcRoom>> = unknown>(wrpcData: WrpcData<WrpcRooms>) => Wrpc<WrpcRooms>;
//#endregion
//#region src/domain/wrpcError.d.ts
declare enum WrpcErrorCode {
  ValidationError = "validation_error",
  RoomNotFound = "room_not_found",
  AlreadyInRoom = "already_in_room",
  RoomFull = "room_full",
  RoomLocked = "room_locked",
  EventNotFound = "event_not_found",
  CommandNotFound = "command_not_found",
  RuntimeError = "runtime_error"
}
interface WrpcErrorConfig<Code extends string = WrpcErrorCode, Data = undefined> {
  code: Code;
  message?: string;
  defined?: boolean;
  data?: Data;
}
declare class WrpcError<Code extends string = WrpcErrorCode, Data = undefined> extends Error {
  readonly code: Code;
  readonly defined: boolean;
  readonly data: Data;
  constructor(config: WrpcErrorConfig<Code, Data>);
}
//#endregion
//#region src/domain/wrpcMessage.d.ts
declare enum WrpcMessageType {
  Config = "config",
  State = "state",
  Metadata = "metadata",
  ConnectionMetadata = "connectionMetadata",
  Create = "create",
  Join = "join",
  Host = "host",
  Leave = "leave",
  Broadcast = "broadcast",
  Event = "event",
  Command = "command",
  Removed = "removed",
  Error = "error"
}
type WrpcMessageConfig = WrpcMessageRoom & {
  type: WrpcMessageType.Config;
  config: WrpcRoomConfig;
};
type WrpcMessageState = WrpcMessageRoom & {
  type: WrpcMessageType.State;
  patches?: Patch[];
};
type WrpcMessageMetadata = WrpcMessageRoom & {
  type: WrpcMessageType.Metadata;
  patches?: Patch[];
};
type WrpcMessageConnectionMetadata = WrpcMessageRoom & {
  type: WrpcMessageType.ConnectionMetadata;
  patches?: Patch[];
};
type WrpcMessageRequest = {
  requestId: number;
};
type WrpcMessageRoom = {
  roomId: string;
};
type WrpcMessageCreateRequest = WrpcMessageRequest & {
  type: WrpcMessageType.Create;
  name: string;
  input: unknown;
};
type WrpcMessageCreateResponse = WrpcMessageRoom & WrpcMessageRequest & {
  type: WrpcMessageType.Create;
};
type WrpcMessageCreate = WrpcMessageCreateRequest | WrpcMessageCreateResponse;
type WrpcMessageJoinRequest = WrpcMessageRoom & WrpcMessageRequest & {
  type: WrpcMessageType.Join;
  input: unknown;
};
type WrpcMessageJoinResponse = WrpcMessageRoom & WrpcMessageRequest & {
  type: WrpcMessageType.Join;
  config: WrpcRoomConfig;
  state: unknown;
  metadata: unknown;
  connectionMetadata: unknown;
};
type WrpcMessageJoin = WrpcMessageJoinRequest | WrpcMessageJoinResponse;
type WrpcMessageHostRequest = WrpcMessageRequest & {
  type: WrpcMessageType.Host;
  name: string;
  createInput: unknown;
  joinInput: unknown;
};
type WrpcMessageHostResponse = WrpcMessageRoom & WrpcMessageRequest & {
  type: WrpcMessageType.Host;
  config: WrpcRoomConfig;
  state: unknown;
  metadata: unknown;
  connectionMetadata: unknown;
};
type WrpcMessageHost = WrpcMessageHostRequest | WrpcMessageHostResponse;
type WrpcMessageLeaveRequest = WrpcMessageRoom & WrpcMessageRequest & {
  type: WrpcMessageType.Leave;
};
type WrpcMessageLeaveResponse = WrpcMessageRoom & WrpcMessageRequest & {
  type: WrpcMessageType.Leave;
};
type WrpcMessageLeave = WrpcMessageLeaveRequest | WrpcMessageLeaveResponse;
type WrpcMessageBroadcast = WrpcMessageRoom & {
  type: WrpcMessageType.Broadcast;
  name: string;
  input: unknown;
};
type WrpcMessageEvent = WrpcMessageRoom & {
  type: WrpcMessageType.Event;
  name: string;
  input: unknown;
};
type WrpcMessageCommandRequest = WrpcMessageRoom & WrpcMessageRequest & {
  type: WrpcMessageType.Command;
  name: string;
  input: unknown;
};
type WrpcMessageCommandResponse = WrpcMessageRoom & WrpcMessageRequest & {
  type: WrpcMessageType.Command;
  name: string;
  output: unknown;
};
type WrpcMessageRemoved = WrpcMessageRoom & {
  type: WrpcMessageType.Removed;
};
type WrpcMessageError = Partial<WrpcMessageRequest> & {
  type: WrpcMessageType.Error;
  code: WrpcErrorCode;
  defined?: boolean;
  message?: string;
  data?: unknown;
};
type WrpcMessageClientRoom = WrpcMessageEvent | WrpcMessageCommandRequest;
type WrpcMessageServerRoom = WrpcMessageConfig | WrpcMessageState | WrpcMessageMetadata | WrpcMessageConnectionMetadata | WrpcMessageBroadcast | WrpcMessageRemoved;
type WrpcMessageClient = WrpcMessageCreateRequest | WrpcMessageJoinRequest | WrpcMessageHostRequest | WrpcMessageLeaveRequest | WrpcMessageClientRoom;
type WrpcMessageServer = WrpcMessageCreateResponse | WrpcMessageJoinResponse | WrpcMessageHostResponse | WrpcMessageLeaveResponse | WrpcMessageCommandResponse | WrpcMessageServerRoom | WrpcMessageError;
type WrpcMessage = WrpcMessageClient | WrpcMessageServer;
//#endregion
//#region src/domain/wrpcRoomBroadcastUtils.d.ts
type ExtractBroadcastNames<Broadcasts extends Maybe<Record<string, WrpcRoomBroadcast>>> = Broadcasts extends Record<string, WrpcRoomBroadcast> ? keyof Broadcasts : never;
type ExtractBroadcastInput<Broadcasts extends Maybe<Record<string, WrpcRoomBroadcast>>, Name extends ExtractBroadcastNames<Broadcasts>, Fallback = unknown> = Broadcasts extends Record<string, WrpcRoomBroadcast> ? Broadcasts[Name] extends WrpcRoomBroadcast<infer Input> ? Input extends Shape ? Input : Fallback : Fallback : Fallback;
//#endregion
//#region src/domain/wrpcRoomCommandUtils.d.ts
type ExtractCommandNames<Commands extends Maybe<Record<string, WrpcRoomCommand>>> = Commands extends Record<string, WrpcRoomCommand> ? keyof Commands : never;
type ExtractCommandInput<Commands extends Maybe<Record<string, WrpcRoomCommand>>, Name extends ExtractCommandNames<Commands>, Fallback = unknown> = Commands extends Record<string, WrpcRoomCommand> ? Commands[Name] extends WrpcRoomCommand<infer Input, unknown> ? Input extends Shape ? Input : Fallback : Fallback : Fallback;
type ExtractCommandOutput<Commands extends Maybe<Record<string, WrpcRoomCommand>>, Name extends ExtractCommandNames<Commands>, Fallback = unknown> = Commands extends Record<string, WrpcRoomCommand> ? Commands[Name] extends WrpcRoomCommand<unknown, infer Output> ? Output extends Shape ? Output : Fallback : Fallback : Fallback;
//#endregion
//#region src/domain/wrpcRoomErrorUtils.d.ts
type ExtractErrorNames<Errors extends Maybe<Record<string, Maybe<Shape>>>> = Errors extends Record<string, Maybe<Shape>> ? keyof Errors : never;
type ExtractErrorData<Errors extends Maybe<Record<string, Maybe<Shape>>>, Name extends ExtractErrorNames<Errors>, Fallback = unknown> = Errors extends Record<string, Maybe<Shape>> ? Name extends keyof Errors ? Errors[Name] extends Shape ? Errors[Name] : Fallback : Fallback : Fallback;
type ExtractRoomErrors<Errors extends Maybe<Record<string, Maybe<Shape>>>> = Errors extends Record<string, Maybe<Shape>> ? { [K in keyof Errors]: WrpcError<K & string, Errors[K] extends Shape ? InferShapeOutput<Errors[K]> : undefined> }[keyof Errors] : never;
//#endregion
//#region src/domain/wrpcRoomEventUtils.d.ts
type ExtractEventNames<Events extends Maybe<Record<string, WrpcRoomEvent>>> = Events extends Record<string, WrpcRoomEvent> ? keyof Events : never;
type ExtractEventInput<Events extends Maybe<Record<string, WrpcRoomEvent>>, Name extends ExtractEventNames<Events>, Fallback = unknown> = Events extends Record<string, WrpcRoomEvent> ? Events[Name] extends WrpcRoomEvent<infer Input> ? Input extends Shape ? Input : Fallback : Fallback : Fallback;
//#endregion
//#region src/domain/wrpcValidationError.d.ts
declare class WrpcValidationError extends WrpcError<WrpcErrorCode.ValidationError, readonly StandardSchemaV1.Issue[]> {
  constructor(issues: readonly StandardSchemaV1.Issue[]);
}
//#endregion
export { ExtractBroadcastInput, ExtractBroadcastNames, ExtractCommandInput, ExtractCommandNames, ExtractCommandOutput, ExtractErrorData, ExtractErrorNames, ExtractEventInput, ExtractEventNames, ExtractRoomErrors, InferShapeInput, InferShapeOutput, Maybe, MaybePromise, MaybeShapeArgs, MaybeShapeListener, Shape, ShapeInvalidResult, ShapeValidResult, ShapeValidateResult, Wrpc, WrpcData, WrpcDefinition, WrpcError, WrpcErrorCode, WrpcErrorConfig, WrpcMessage, WrpcMessageBroadcast, WrpcMessageClient, WrpcMessageClientRoom, WrpcMessageCommandRequest, WrpcMessageCommandResponse, WrpcMessageConfig, WrpcMessageConnectionMetadata, WrpcMessageCreate, WrpcMessageCreateRequest, WrpcMessageCreateResponse, WrpcMessageError, WrpcMessageEvent, WrpcMessageHost, WrpcMessageHostRequest, WrpcMessageHostResponse, WrpcMessageJoin, WrpcMessageJoinRequest, WrpcMessageJoinResponse, WrpcMessageLeave, WrpcMessageLeaveRequest, WrpcMessageLeaveResponse, WrpcMessageMetadata, WrpcMessageRemoved, WrpcMessageRequest, WrpcMessageRoom, WrpcMessageServer, WrpcMessageServerRoom, WrpcMessageState, WrpcMessageType, WrpcRoom, WrpcRoomBroadcast, WrpcRoomBroadcasts, WrpcRoomCommand, WrpcRoomCommands, WrpcRoomConfig, WrpcRoomConnectionMetadata, WrpcRoomData, WrpcRoomDefinition, WrpcRoomErrors, WrpcRoomEvent, WrpcRoomEvents, WrpcRoomLifecycles, WrpcRoomMetadata, WrpcRoomSettings, WrpcRoomState, WrpcValidationError, defineWrpc, defineWrpcRoom, defineWrpcRoomBroadcast, defineWrpcRoomCommand, defineWrpcRoomEvent, validateShape };
//# sourceMappingURL=main.d.mts.map