import { C as PHBaseState, i as Action, w as PHDocument } from "./index-DQ5mRIVf.js";

//#region document-models/voice/v1/gen/config/actions.d.ts
type SetChannelIdAction = Action & {
  type: "SET_CHANNEL_ID";
  input: SetChannelIdInput;
};
type SetMaxParticipantsAction = Action & {
  type: "SET_MAX_PARTICIPANTS";
  input: SetMaxParticipantsInput;
};
type VoiceConfigAction = SetChannelIdAction | SetMaxParticipantsAction;
//#endregion
//#region document-models/voice/v1/gen/voice/actions.d.ts
type JoinVoiceAction = Action & {
  type: "JOIN_VOICE";
  input: JoinVoiceInput;
};
type LeaveVoiceAction = Action & {
  type: "LEAVE_VOICE";
  input: LeaveVoiceInput;
};
type MuteAction = Action & {
  type: "MUTE";
  input: MuteInput;
};
type UnmuteAction = Action & {
  type: "UNMUTE";
  input: UnmuteInput;
};
type DeafenAction = Action & {
  type: "DEAFEN";
  input: DeafenInput;
};
type UndeafenAction = Action & {
  type: "UNDEAFEN";
  input: UndeafenInput;
};
type VoiceVoiceAction = JoinVoiceAction | LeaveVoiceAction | MuteAction | UnmuteAction | DeafenAction | UndeafenAction;
//#endregion
//#region document-models/voice/v1/gen/actions.d.ts
type VoiceAction = VoiceConfigAction | VoiceVoiceAction;
//#endregion
//#region document-models/voice/v1/gen/schema/types.d.ts
type Maybe<T> = T | null | undefined;
type InputMaybe<T> = T | null | undefined;
type Exact<T extends {
  [key: string]: unknown;
}> = { [K in keyof T]: T[K] };
type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
type MakeEmpty<T extends {
  [key: string]: unknown;
}, K extends keyof T> = { [_ in K]?: never };
type Incremental<T> = T | { [P in keyof T]?: P extends " $fragmentName" | "__typename" ? T[P] : never };
/** All built-in and custom scalars, mapped to their actual values */
type Scalars = {
  ID: {
    input: string;
    output: string;
  };
  String: {
    input: string;
    output: string;
  };
  Boolean: {
    input: boolean;
    output: boolean;
  };
  Int: {
    input: number;
    output: number;
  };
  Float: {
    input: number;
    output: number;
  };
  Address: {
    input: `${string}:0x${string}`;
    output: `${string}:0x${string}`;
  };
  Amount: {
    input: {
      unit?: string;
      value?: number;
    };
    output: {
      unit?: string;
      value?: number;
    };
  };
  Amount_Crypto: {
    input: {
      unit: string;
      value: string;
    };
    output: {
      unit: string;
      value: string;
    };
  };
  Amount_Currency: {
    input: {
      unit: string;
      value: string;
    };
    output: {
      unit: string;
      value: string;
    };
  };
  Amount_Fiat: {
    input: {
      unit: string;
      value: number;
    };
    output: {
      unit: string;
      value: number;
    };
  };
  Amount_Money: {
    input: number;
    output: number;
  };
  Amount_Percentage: {
    input: number;
    output: number;
  };
  Amount_Tokens: {
    input: number;
    output: number;
  };
  Attachment: {
    input: string;
    output: string;
  };
  Currency: {
    input: string;
    output: string;
  };
  Date: {
    input: string;
    output: string;
  };
  DateTime: {
    input: string;
    output: string;
  };
  EmailAddress: {
    input: string;
    output: string;
  };
  EthereumAddress: {
    input: string;
    output: string;
  };
  OID: {
    input: string;
    output: string;
  };
  OLabel: {
    input: string;
    output: string;
  };
  PHID: {
    input: string;
    output: string;
  };
  URL: {
    input: string;
    output: string;
  };
  Unknown: {
    input: unknown;
    output: unknown;
  };
  Upload: {
    input: File;
    output: File;
  };
};
type DeafenInput = {
  participantId: Scalars["OID"]["input"];
};
type JoinVoiceInput = {
  avatar?: InputMaybe<Scalars["String"]["input"]>;
  id: Scalars["OID"]["input"];
  joinedAt: Scalars["DateTime"]["input"];
  name: Scalars["String"]["input"];
};
type LeaveVoiceInput = {
  participantId: Scalars["OID"]["input"];
};
type MuteInput = {
  participantId: Scalars["OID"]["input"];
};
type SetChannelIdInput = {
  channelId: Scalars["PHID"]["input"];
};
type SetMaxParticipantsInput = {
  maxParticipants?: InputMaybe<Scalars["Int"]["input"]>;
};
type UndeafenInput = {
  participantId: Scalars["OID"]["input"];
};
type UnmuteInput = {
  participantId: Scalars["OID"]["input"];
};
type VoiceParticipant = {
  avatar: Maybe<Scalars["String"]["output"]>;
  id: Scalars["OID"]["output"];
  isDeafened: Scalars["Boolean"]["output"];
  isMuted: Scalars["Boolean"]["output"];
  joinedAt: Scalars["DateTime"]["output"];
  name: Scalars["String"]["output"];
};
type VoiceState = {
  activeParticipants: Array<VoiceParticipant>;
  channelId: Maybe<Scalars["PHID"]["output"]>;
  maxParticipants: Maybe<Scalars["Int"]["output"]>;
};
//#endregion
//#region document-models/voice/v1/gen/types.d.ts
type VoiceLocalState = Record<PropertyKey, never>;
type VoicePHState = PHBaseState & {
  global: VoiceState;
  local: VoiceLocalState;
};
type VoiceDocument = PHDocument<VoicePHState>;
//#endregion
export { SetChannelIdAction as A, DeafenAction as C, UndeafenAction as D, MuteAction as E, VoiceConfigAction as M, UnmuteAction as O, VoiceAction as S, LeaveVoiceAction as T, SetMaxParticipantsInput as _, Exact as a, VoiceParticipant as b, JoinVoiceInput as c, MakeMaybe as d, MakeOptional as f, SetChannelIdInput as g, Scalars as h, DeafenInput as i, SetMaxParticipantsAction as j, VoiceVoiceAction as k, LeaveVoiceInput as l, MuteInput as m, VoiceLocalState as n, Incremental as o, Maybe as p, VoicePHState as r, InputMaybe as s, VoiceDocument as t, MakeEmpty as u, UndeafenInput as v, JoinVoiceAction as w, VoiceState as x, UnmuteInput as y };
//# sourceMappingURL=types-B4j5h3uv.d.ts.map