/*
 * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
 */

import * as z from "zod";
import { remap as remap$ } from "../../../lib/primitives.js";

export type AdminGetUserRequest = {
  id: number;
};

export type ApprovedBy = {
  avatarTemplate: string;
  id: number;
  name: string;
  username: string;
};

export type AdminGetUserExternalIds = {};

export type AdminGetUserGroups = {
  allowMembershipRequests: boolean;
  automatic: boolean;
  bioCooked: string | null;
  bioExcerpt: string | null;
  bioRaw: string | null;
  canAdminGroup: boolean;
  canSeeMembers: boolean;
  defaultNotificationLevel: number;
  displayName: string;
  flairBgColor: string | null;
  flairColor: string | null;
  flairGroupId?: string | null | undefined;
  flairUrl: string | null;
  fullName: string | null;
  grantTrustLevel: string | null;
  hasMessages: boolean;
  id: number;
  incomingEmail: string | null;
  membersVisibilityLevel: number;
  membershipRequestTemplate: string | null;
  mentionableLevel: number;
  messageableLevel: number;
  name: string;
  primaryGroup: boolean;
  publicAdmission: boolean;
  publicExit: boolean;
  publishReadState: boolean;
  title: string | null;
  userCount: number;
  visibilityLevel: number;
};

export type PenaltyCounts = {
  silenced: number;
  suspended: number;
};

export type AdminGetUserPenaltyCounts = {
  silenced: number;
  suspended: number;
  total: number;
};

export type Tl3Requirements = {
  daysVisited: number;
  maxFlaggedByUsers: number;
  maxFlaggedPosts: number;
  minDaysVisited: number;
  minLikesGiven: number;
  minLikesReceived: number;
  minLikesReceivedDays: number;
  minLikesReceivedUsers: number;
  minPostsRead: number;
  minPostsReadAllTime: number;
  minTopicsRepliedTo: number;
  minTopicsViewed: number;
  minTopicsViewedAllTime: number;
  numFlaggedByUsers: number;
  numFlaggedPosts: number;
  numLikesGiven: number;
  numLikesReceived: number;
  numLikesReceivedDays: number;
  numLikesReceivedUsers: number;
  numTopicsRepliedTo: number;
  onGracePeriod: boolean;
  penaltyCounts: AdminGetUserPenaltyCounts;
  postsRead: number;
  postsReadAllTime: number;
  requirementsLost: boolean;
  requirementsMet: boolean;
  timePeriod: number;
  topicsViewed: number;
  topicsViewedAllTime: number;
  trustLevelLocked: boolean;
};

/**
 * response
 */
export type AdminGetUserResponseBody = {
  active: boolean;
  admin: boolean;
  apiKeyCount: number;
  approvedBy: ApprovedBy | null;
  associatedAccounts?: Array<any> | undefined;
  avatarTemplate: string;
  badgeCount: number;
  bounceScore: number | null;
  canActivate: boolean;
  canBeAnonymized: boolean;
  canBeDeleted: boolean;
  canBeMerged: boolean;
  canDeactivate: boolean;
  canDeleteAllPosts: boolean;
  canDeleteSsoRecord: boolean;
  canDisableSecondFactor: boolean;
  canGrantAdmin: boolean;
  canGrantModeration: boolean;
  canImpersonate: boolean;
  canRevokeAdmin: boolean;
  canRevokeModeration: boolean;
  canSendActivationEmail: boolean;
  canViewActionLogs: boolean;
  createdAt: string;
  createdAtAge: number | null;
  daysVisited: number;
  externalIds: AdminGetUserExternalIds;
  flagsGivenCount: number;
  flagsReceivedCount: number;
  fullSuspendReason: string | null;
  groups: Array<AdminGetUserGroups>;
  id: number;
  ipAddress: string;
  lastEmailedAge: number | null;
  lastEmailedAt: string | null;
  lastSeenAge: number | null;
  lastSeenAt: string | null;
  likeCount: number;
  likeGivenCount: number;
  manualLockedTrustLevel: string | null;
  moderator: boolean;
  name: string | null;
  nextPenalty?: string | undefined;
  penaltyCounts?: PenaltyCounts | undefined;
  postCount: number;
  postEditsCount?: number | null | undefined;
  postsReadCount: number;
  primaryGroupId: string | null;
  privateTopicsCount: number;
  registrationIpAddress: string | null;
  resetBounceScoreAfter: string | null;
  silenceReason: string | null;
  silencedBy: string | null;
  singleSignOnRecord: string | null;
  staged: boolean;
  suspendedBy: string | null;
  timeRead: number;
  title: string | null;
  tl3Requirements?: Tl3Requirements | undefined;
  topicCount: number;
  topicsEntered: number;
  trustLevel: number;
  username: string;
  warningsReceivedCount: number;
};

/** @internal */
export const AdminGetUserRequest$inboundSchema: z.ZodType<
  AdminGetUserRequest,
  z.ZodTypeDef,
  unknown
> = z.object({
  id: z.number().int(),
});

/** @internal */
export type AdminGetUserRequest$Outbound = {
  id: number;
};

/** @internal */
export const AdminGetUserRequest$outboundSchema: z.ZodType<
  AdminGetUserRequest$Outbound,
  z.ZodTypeDef,
  AdminGetUserRequest
> = z.object({
  id: z.number().int(),
});

/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export namespace AdminGetUserRequest$ {
  /** @deprecated use `AdminGetUserRequest$inboundSchema` instead. */
  export const inboundSchema = AdminGetUserRequest$inboundSchema;
  /** @deprecated use `AdminGetUserRequest$outboundSchema` instead. */
  export const outboundSchema = AdminGetUserRequest$outboundSchema;
  /** @deprecated use `AdminGetUserRequest$Outbound` instead. */
  export type Outbound = AdminGetUserRequest$Outbound;
}

/** @internal */
export const ApprovedBy$inboundSchema: z.ZodType<
  ApprovedBy,
  z.ZodTypeDef,
  unknown
> = z.object({
  avatar_template: z.string(),
  id: z.number().int(),
  name: z.string(),
  username: z.string(),
}).transform((v) => {
  return remap$(v, {
    "avatar_template": "avatarTemplate",
  });
});

/** @internal */
export type ApprovedBy$Outbound = {
  avatar_template: string;
  id: number;
  name: string;
  username: string;
};

/** @internal */
export const ApprovedBy$outboundSchema: z.ZodType<
  ApprovedBy$Outbound,
  z.ZodTypeDef,
  ApprovedBy
> = z.object({
  avatarTemplate: z.string(),
  id: z.number().int(),
  name: z.string(),
  username: z.string(),
}).transform((v) => {
  return remap$(v, {
    avatarTemplate: "avatar_template",
  });
});

/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export namespace ApprovedBy$ {
  /** @deprecated use `ApprovedBy$inboundSchema` instead. */
  export const inboundSchema = ApprovedBy$inboundSchema;
  /** @deprecated use `ApprovedBy$outboundSchema` instead. */
  export const outboundSchema = ApprovedBy$outboundSchema;
  /** @deprecated use `ApprovedBy$Outbound` instead. */
  export type Outbound = ApprovedBy$Outbound;
}

/** @internal */
export const AdminGetUserExternalIds$inboundSchema: z.ZodType<
  AdminGetUserExternalIds,
  z.ZodTypeDef,
  unknown
> = z.object({});

/** @internal */
export type AdminGetUserExternalIds$Outbound = {};

/** @internal */
export const AdminGetUserExternalIds$outboundSchema: z.ZodType<
  AdminGetUserExternalIds$Outbound,
  z.ZodTypeDef,
  AdminGetUserExternalIds
> = z.object({});

/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export namespace AdminGetUserExternalIds$ {
  /** @deprecated use `AdminGetUserExternalIds$inboundSchema` instead. */
  export const inboundSchema = AdminGetUserExternalIds$inboundSchema;
  /** @deprecated use `AdminGetUserExternalIds$outboundSchema` instead. */
  export const outboundSchema = AdminGetUserExternalIds$outboundSchema;
  /** @deprecated use `AdminGetUserExternalIds$Outbound` instead. */
  export type Outbound = AdminGetUserExternalIds$Outbound;
}

/** @internal */
export const AdminGetUserGroups$inboundSchema: z.ZodType<
  AdminGetUserGroups,
  z.ZodTypeDef,
  unknown
> = z.object({
  allow_membership_requests: z.boolean(),
  automatic: z.boolean(),
  bio_cooked: z.nullable(z.string()),
  bio_excerpt: z.nullable(z.string()),
  bio_raw: z.nullable(z.string()),
  can_admin_group: z.boolean(),
  can_see_members: z.boolean(),
  default_notification_level: z.number().int(),
  display_name: z.string(),
  flair_bg_color: z.nullable(z.string()),
  flair_color: z.nullable(z.string()),
  flair_group_id: z.nullable(z.string()).optional(),
  flair_url: z.nullable(z.string()),
  full_name: z.nullable(z.string()),
  grant_trust_level: z.nullable(z.string()),
  has_messages: z.boolean(),
  id: z.number().int(),
  incoming_email: z.nullable(z.string()),
  members_visibility_level: z.number().int(),
  membership_request_template: z.nullable(z.string()),
  mentionable_level: z.number().int(),
  messageable_level: z.number().int(),
  name: z.string(),
  primary_group: z.boolean(),
  public_admission: z.boolean(),
  public_exit: z.boolean(),
  publish_read_state: z.boolean(),
  title: z.nullable(z.string()),
  user_count: z.number().int(),
  visibility_level: z.number().int(),
}).transform((v) => {
  return remap$(v, {
    "allow_membership_requests": "allowMembershipRequests",
    "bio_cooked": "bioCooked",
    "bio_excerpt": "bioExcerpt",
    "bio_raw": "bioRaw",
    "can_admin_group": "canAdminGroup",
    "can_see_members": "canSeeMembers",
    "default_notification_level": "defaultNotificationLevel",
    "display_name": "displayName",
    "flair_bg_color": "flairBgColor",
    "flair_color": "flairColor",
    "flair_group_id": "flairGroupId",
    "flair_url": "flairUrl",
    "full_name": "fullName",
    "grant_trust_level": "grantTrustLevel",
    "has_messages": "hasMessages",
    "incoming_email": "incomingEmail",
    "members_visibility_level": "membersVisibilityLevel",
    "membership_request_template": "membershipRequestTemplate",
    "mentionable_level": "mentionableLevel",
    "messageable_level": "messageableLevel",
    "primary_group": "primaryGroup",
    "public_admission": "publicAdmission",
    "public_exit": "publicExit",
    "publish_read_state": "publishReadState",
    "user_count": "userCount",
    "visibility_level": "visibilityLevel",
  });
});

/** @internal */
export type AdminGetUserGroups$Outbound = {
  allow_membership_requests: boolean;
  automatic: boolean;
  bio_cooked: string | null;
  bio_excerpt: string | null;
  bio_raw: string | null;
  can_admin_group: boolean;
  can_see_members: boolean;
  default_notification_level: number;
  display_name: string;
  flair_bg_color: string | null;
  flair_color: string | null;
  flair_group_id?: string | null | undefined;
  flair_url: string | null;
  full_name: string | null;
  grant_trust_level: string | null;
  has_messages: boolean;
  id: number;
  incoming_email: string | null;
  members_visibility_level: number;
  membership_request_template: string | null;
  mentionable_level: number;
  messageable_level: number;
  name: string;
  primary_group: boolean;
  public_admission: boolean;
  public_exit: boolean;
  publish_read_state: boolean;
  title: string | null;
  user_count: number;
  visibility_level: number;
};

/** @internal */
export const AdminGetUserGroups$outboundSchema: z.ZodType<
  AdminGetUserGroups$Outbound,
  z.ZodTypeDef,
  AdminGetUserGroups
> = z.object({
  allowMembershipRequests: z.boolean(),
  automatic: z.boolean(),
  bioCooked: z.nullable(z.string()),
  bioExcerpt: z.nullable(z.string()),
  bioRaw: z.nullable(z.string()),
  canAdminGroup: z.boolean(),
  canSeeMembers: z.boolean(),
  defaultNotificationLevel: z.number().int(),
  displayName: z.string(),
  flairBgColor: z.nullable(z.string()),
  flairColor: z.nullable(z.string()),
  flairGroupId: z.nullable(z.string()).optional(),
  flairUrl: z.nullable(z.string()),
  fullName: z.nullable(z.string()),
  grantTrustLevel: z.nullable(z.string()),
  hasMessages: z.boolean(),
  id: z.number().int(),
  incomingEmail: z.nullable(z.string()),
  membersVisibilityLevel: z.number().int(),
  membershipRequestTemplate: z.nullable(z.string()),
  mentionableLevel: z.number().int(),
  messageableLevel: z.number().int(),
  name: z.string(),
  primaryGroup: z.boolean(),
  publicAdmission: z.boolean(),
  publicExit: z.boolean(),
  publishReadState: z.boolean(),
  title: z.nullable(z.string()),
  userCount: z.number().int(),
  visibilityLevel: z.number().int(),
}).transform((v) => {
  return remap$(v, {
    allowMembershipRequests: "allow_membership_requests",
    bioCooked: "bio_cooked",
    bioExcerpt: "bio_excerpt",
    bioRaw: "bio_raw",
    canAdminGroup: "can_admin_group",
    canSeeMembers: "can_see_members",
    defaultNotificationLevel: "default_notification_level",
    displayName: "display_name",
    flairBgColor: "flair_bg_color",
    flairColor: "flair_color",
    flairGroupId: "flair_group_id",
    flairUrl: "flair_url",
    fullName: "full_name",
    grantTrustLevel: "grant_trust_level",
    hasMessages: "has_messages",
    incomingEmail: "incoming_email",
    membersVisibilityLevel: "members_visibility_level",
    membershipRequestTemplate: "membership_request_template",
    mentionableLevel: "mentionable_level",
    messageableLevel: "messageable_level",
    primaryGroup: "primary_group",
    publicAdmission: "public_admission",
    publicExit: "public_exit",
    publishReadState: "publish_read_state",
    userCount: "user_count",
    visibilityLevel: "visibility_level",
  });
});

/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export namespace AdminGetUserGroups$ {
  /** @deprecated use `AdminGetUserGroups$inboundSchema` instead. */
  export const inboundSchema = AdminGetUserGroups$inboundSchema;
  /** @deprecated use `AdminGetUserGroups$outboundSchema` instead. */
  export const outboundSchema = AdminGetUserGroups$outboundSchema;
  /** @deprecated use `AdminGetUserGroups$Outbound` instead. */
  export type Outbound = AdminGetUserGroups$Outbound;
}

/** @internal */
export const PenaltyCounts$inboundSchema: z.ZodType<
  PenaltyCounts,
  z.ZodTypeDef,
  unknown
> = z.object({
  silenced: z.number().int(),
  suspended: z.number().int(),
});

/** @internal */
export type PenaltyCounts$Outbound = {
  silenced: number;
  suspended: number;
};

/** @internal */
export const PenaltyCounts$outboundSchema: z.ZodType<
  PenaltyCounts$Outbound,
  z.ZodTypeDef,
  PenaltyCounts
> = z.object({
  silenced: z.number().int(),
  suspended: z.number().int(),
});

/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export namespace PenaltyCounts$ {
  /** @deprecated use `PenaltyCounts$inboundSchema` instead. */
  export const inboundSchema = PenaltyCounts$inboundSchema;
  /** @deprecated use `PenaltyCounts$outboundSchema` instead. */
  export const outboundSchema = PenaltyCounts$outboundSchema;
  /** @deprecated use `PenaltyCounts$Outbound` instead. */
  export type Outbound = PenaltyCounts$Outbound;
}

/** @internal */
export const AdminGetUserPenaltyCounts$inboundSchema: z.ZodType<
  AdminGetUserPenaltyCounts,
  z.ZodTypeDef,
  unknown
> = z.object({
  silenced: z.number().int(),
  suspended: z.number().int(),
  total: z.number().int(),
});

/** @internal */
export type AdminGetUserPenaltyCounts$Outbound = {
  silenced: number;
  suspended: number;
  total: number;
};

/** @internal */
export const AdminGetUserPenaltyCounts$outboundSchema: z.ZodType<
  AdminGetUserPenaltyCounts$Outbound,
  z.ZodTypeDef,
  AdminGetUserPenaltyCounts
> = z.object({
  silenced: z.number().int(),
  suspended: z.number().int(),
  total: z.number().int(),
});

/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export namespace AdminGetUserPenaltyCounts$ {
  /** @deprecated use `AdminGetUserPenaltyCounts$inboundSchema` instead. */
  export const inboundSchema = AdminGetUserPenaltyCounts$inboundSchema;
  /** @deprecated use `AdminGetUserPenaltyCounts$outboundSchema` instead. */
  export const outboundSchema = AdminGetUserPenaltyCounts$outboundSchema;
  /** @deprecated use `AdminGetUserPenaltyCounts$Outbound` instead. */
  export type Outbound = AdminGetUserPenaltyCounts$Outbound;
}

/** @internal */
export const Tl3Requirements$inboundSchema: z.ZodType<
  Tl3Requirements,
  z.ZodTypeDef,
  unknown
> = z.object({
  days_visited: z.number().int(),
  max_flagged_by_users: z.number().int(),
  max_flagged_posts: z.number().int(),
  min_days_visited: z.number().int(),
  min_likes_given: z.number().int(),
  min_likes_received: z.number().int(),
  min_likes_received_days: z.number().int(),
  min_likes_received_users: z.number().int(),
  min_posts_read: z.number().int(),
  min_posts_read_all_time: z.number().int(),
  min_topics_replied_to: z.number().int(),
  min_topics_viewed: z.number().int(),
  min_topics_viewed_all_time: z.number().int(),
  num_flagged_by_users: z.number().int(),
  num_flagged_posts: z.number().int(),
  num_likes_given: z.number().int(),
  num_likes_received: z.number().int(),
  num_likes_received_days: z.number().int(),
  num_likes_received_users: z.number().int(),
  num_topics_replied_to: z.number().int(),
  on_grace_period: z.boolean(),
  penalty_counts: z.lazy(() => AdminGetUserPenaltyCounts$inboundSchema),
  posts_read: z.number().int(),
  posts_read_all_time: z.number().int(),
  requirements_lost: z.boolean(),
  requirements_met: z.boolean(),
  time_period: z.number().int(),
  topics_viewed: z.number().int(),
  topics_viewed_all_time: z.number().int(),
  trust_level_locked: z.boolean(),
}).transform((v) => {
  return remap$(v, {
    "days_visited": "daysVisited",
    "max_flagged_by_users": "maxFlaggedByUsers",
    "max_flagged_posts": "maxFlaggedPosts",
    "min_days_visited": "minDaysVisited",
    "min_likes_given": "minLikesGiven",
    "min_likes_received": "minLikesReceived",
    "min_likes_received_days": "minLikesReceivedDays",
    "min_likes_received_users": "minLikesReceivedUsers",
    "min_posts_read": "minPostsRead",
    "min_posts_read_all_time": "minPostsReadAllTime",
    "min_topics_replied_to": "minTopicsRepliedTo",
    "min_topics_viewed": "minTopicsViewed",
    "min_topics_viewed_all_time": "minTopicsViewedAllTime",
    "num_flagged_by_users": "numFlaggedByUsers",
    "num_flagged_posts": "numFlaggedPosts",
    "num_likes_given": "numLikesGiven",
    "num_likes_received": "numLikesReceived",
    "num_likes_received_days": "numLikesReceivedDays",
    "num_likes_received_users": "numLikesReceivedUsers",
    "num_topics_replied_to": "numTopicsRepliedTo",
    "on_grace_period": "onGracePeriod",
    "penalty_counts": "penaltyCounts",
    "posts_read": "postsRead",
    "posts_read_all_time": "postsReadAllTime",
    "requirements_lost": "requirementsLost",
    "requirements_met": "requirementsMet",
    "time_period": "timePeriod",
    "topics_viewed": "topicsViewed",
    "topics_viewed_all_time": "topicsViewedAllTime",
    "trust_level_locked": "trustLevelLocked",
  });
});

/** @internal */
export type Tl3Requirements$Outbound = {
  days_visited: number;
  max_flagged_by_users: number;
  max_flagged_posts: number;
  min_days_visited: number;
  min_likes_given: number;
  min_likes_received: number;
  min_likes_received_days: number;
  min_likes_received_users: number;
  min_posts_read: number;
  min_posts_read_all_time: number;
  min_topics_replied_to: number;
  min_topics_viewed: number;
  min_topics_viewed_all_time: number;
  num_flagged_by_users: number;
  num_flagged_posts: number;
  num_likes_given: number;
  num_likes_received: number;
  num_likes_received_days: number;
  num_likes_received_users: number;
  num_topics_replied_to: number;
  on_grace_period: boolean;
  penalty_counts: AdminGetUserPenaltyCounts$Outbound;
  posts_read: number;
  posts_read_all_time: number;
  requirements_lost: boolean;
  requirements_met: boolean;
  time_period: number;
  topics_viewed: number;
  topics_viewed_all_time: number;
  trust_level_locked: boolean;
};

/** @internal */
export const Tl3Requirements$outboundSchema: z.ZodType<
  Tl3Requirements$Outbound,
  z.ZodTypeDef,
  Tl3Requirements
> = z.object({
  daysVisited: z.number().int(),
  maxFlaggedByUsers: z.number().int(),
  maxFlaggedPosts: z.number().int(),
  minDaysVisited: z.number().int(),
  minLikesGiven: z.number().int(),
  minLikesReceived: z.number().int(),
  minLikesReceivedDays: z.number().int(),
  minLikesReceivedUsers: z.number().int(),
  minPostsRead: z.number().int(),
  minPostsReadAllTime: z.number().int(),
  minTopicsRepliedTo: z.number().int(),
  minTopicsViewed: z.number().int(),
  minTopicsViewedAllTime: z.number().int(),
  numFlaggedByUsers: z.number().int(),
  numFlaggedPosts: z.number().int(),
  numLikesGiven: z.number().int(),
  numLikesReceived: z.number().int(),
  numLikesReceivedDays: z.number().int(),
  numLikesReceivedUsers: z.number().int(),
  numTopicsRepliedTo: z.number().int(),
  onGracePeriod: z.boolean(),
  penaltyCounts: z.lazy(() => AdminGetUserPenaltyCounts$outboundSchema),
  postsRead: z.number().int(),
  postsReadAllTime: z.number().int(),
  requirementsLost: z.boolean(),
  requirementsMet: z.boolean(),
  timePeriod: z.number().int(),
  topicsViewed: z.number().int(),
  topicsViewedAllTime: z.number().int(),
  trustLevelLocked: z.boolean(),
}).transform((v) => {
  return remap$(v, {
    daysVisited: "days_visited",
    maxFlaggedByUsers: "max_flagged_by_users",
    maxFlaggedPosts: "max_flagged_posts",
    minDaysVisited: "min_days_visited",
    minLikesGiven: "min_likes_given",
    minLikesReceived: "min_likes_received",
    minLikesReceivedDays: "min_likes_received_days",
    minLikesReceivedUsers: "min_likes_received_users",
    minPostsRead: "min_posts_read",
    minPostsReadAllTime: "min_posts_read_all_time",
    minTopicsRepliedTo: "min_topics_replied_to",
    minTopicsViewed: "min_topics_viewed",
    minTopicsViewedAllTime: "min_topics_viewed_all_time",
    numFlaggedByUsers: "num_flagged_by_users",
    numFlaggedPosts: "num_flagged_posts",
    numLikesGiven: "num_likes_given",
    numLikesReceived: "num_likes_received",
    numLikesReceivedDays: "num_likes_received_days",
    numLikesReceivedUsers: "num_likes_received_users",
    numTopicsRepliedTo: "num_topics_replied_to",
    onGracePeriod: "on_grace_period",
    penaltyCounts: "penalty_counts",
    postsRead: "posts_read",
    postsReadAllTime: "posts_read_all_time",
    requirementsLost: "requirements_lost",
    requirementsMet: "requirements_met",
    timePeriod: "time_period",
    topicsViewed: "topics_viewed",
    topicsViewedAllTime: "topics_viewed_all_time",
    trustLevelLocked: "trust_level_locked",
  });
});

/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export namespace Tl3Requirements$ {
  /** @deprecated use `Tl3Requirements$inboundSchema` instead. */
  export const inboundSchema = Tl3Requirements$inboundSchema;
  /** @deprecated use `Tl3Requirements$outboundSchema` instead. */
  export const outboundSchema = Tl3Requirements$outboundSchema;
  /** @deprecated use `Tl3Requirements$Outbound` instead. */
  export type Outbound = Tl3Requirements$Outbound;
}

/** @internal */
export const AdminGetUserResponseBody$inboundSchema: z.ZodType<
  AdminGetUserResponseBody,
  z.ZodTypeDef,
  unknown
> = z.object({
  active: z.boolean(),
  admin: z.boolean(),
  api_key_count: z.number().int(),
  approved_by: z.nullable(z.lazy(() => ApprovedBy$inboundSchema)),
  associated_accounts: z.array(z.any()).optional(),
  avatar_template: z.string(),
  badge_count: z.number().int(),
  bounce_score: z.nullable(z.number().int()),
  can_activate: z.boolean(),
  can_be_anonymized: z.boolean(),
  can_be_deleted: z.boolean(),
  can_be_merged: z.boolean(),
  can_deactivate: z.boolean(),
  can_delete_all_posts: z.boolean(),
  can_delete_sso_record: z.boolean(),
  can_disable_second_factor: z.boolean(),
  can_grant_admin: z.boolean(),
  can_grant_moderation: z.boolean(),
  can_impersonate: z.boolean(),
  can_revoke_admin: z.boolean(),
  can_revoke_moderation: z.boolean(),
  can_send_activation_email: z.boolean(),
  can_view_action_logs: z.boolean(),
  created_at: z.string(),
  created_at_age: z.nullable(z.number()),
  days_visited: z.number().int(),
  external_ids: z.lazy(() => AdminGetUserExternalIds$inboundSchema),
  flags_given_count: z.number().int(),
  flags_received_count: z.number().int(),
  full_suspend_reason: z.nullable(z.string()),
  groups: z.array(z.lazy(() => AdminGetUserGroups$inboundSchema)),
  id: z.number().int(),
  ip_address: z.string(),
  last_emailed_age: z.nullable(z.number()),
  last_emailed_at: z.nullable(z.string()),
  last_seen_age: z.nullable(z.number()),
  last_seen_at: z.nullable(z.string()),
  like_count: z.number().int(),
  like_given_count: z.number().int(),
  manual_locked_trust_level: z.nullable(z.string()),
  moderator: z.boolean(),
  name: z.nullable(z.string()),
  next_penalty: z.string().optional(),
  penalty_counts: z.lazy(() => PenaltyCounts$inboundSchema).optional(),
  post_count: z.number().int(),
  post_edits_count: z.nullable(z.number().int()).optional(),
  posts_read_count: z.number().int(),
  primary_group_id: z.nullable(z.string()),
  private_topics_count: z.number().int(),
  registration_ip_address: z.nullable(z.string()),
  reset_bounce_score_after: z.nullable(z.string()),
  silence_reason: z.nullable(z.string()),
  silenced_by: z.nullable(z.string()),
  single_sign_on_record: z.nullable(z.string()),
  staged: z.boolean(),
  suspended_by: z.nullable(z.string()),
  time_read: z.number().int(),
  title: z.nullable(z.string()),
  tl3_requirements: z.lazy(() => Tl3Requirements$inboundSchema).optional(),
  topic_count: z.number().int(),
  topics_entered: z.number().int(),
  trust_level: z.number().int(),
  username: z.string(),
  warnings_received_count: z.number().int(),
}).transform((v) => {
  return remap$(v, {
    "api_key_count": "apiKeyCount",
    "approved_by": "approvedBy",
    "associated_accounts": "associatedAccounts",
    "avatar_template": "avatarTemplate",
    "badge_count": "badgeCount",
    "bounce_score": "bounceScore",
    "can_activate": "canActivate",
    "can_be_anonymized": "canBeAnonymized",
    "can_be_deleted": "canBeDeleted",
    "can_be_merged": "canBeMerged",
    "can_deactivate": "canDeactivate",
    "can_delete_all_posts": "canDeleteAllPosts",
    "can_delete_sso_record": "canDeleteSsoRecord",
    "can_disable_second_factor": "canDisableSecondFactor",
    "can_grant_admin": "canGrantAdmin",
    "can_grant_moderation": "canGrantModeration",
    "can_impersonate": "canImpersonate",
    "can_revoke_admin": "canRevokeAdmin",
    "can_revoke_moderation": "canRevokeModeration",
    "can_send_activation_email": "canSendActivationEmail",
    "can_view_action_logs": "canViewActionLogs",
    "created_at": "createdAt",
    "created_at_age": "createdAtAge",
    "days_visited": "daysVisited",
    "external_ids": "externalIds",
    "flags_given_count": "flagsGivenCount",
    "flags_received_count": "flagsReceivedCount",
    "full_suspend_reason": "fullSuspendReason",
    "ip_address": "ipAddress",
    "last_emailed_age": "lastEmailedAge",
    "last_emailed_at": "lastEmailedAt",
    "last_seen_age": "lastSeenAge",
    "last_seen_at": "lastSeenAt",
    "like_count": "likeCount",
    "like_given_count": "likeGivenCount",
    "manual_locked_trust_level": "manualLockedTrustLevel",
    "next_penalty": "nextPenalty",
    "penalty_counts": "penaltyCounts",
    "post_count": "postCount",
    "post_edits_count": "postEditsCount",
    "posts_read_count": "postsReadCount",
    "primary_group_id": "primaryGroupId",
    "private_topics_count": "privateTopicsCount",
    "registration_ip_address": "registrationIpAddress",
    "reset_bounce_score_after": "resetBounceScoreAfter",
    "silence_reason": "silenceReason",
    "silenced_by": "silencedBy",
    "single_sign_on_record": "singleSignOnRecord",
    "suspended_by": "suspendedBy",
    "time_read": "timeRead",
    "tl3_requirements": "tl3Requirements",
    "topic_count": "topicCount",
    "topics_entered": "topicsEntered",
    "trust_level": "trustLevel",
    "warnings_received_count": "warningsReceivedCount",
  });
});

/** @internal */
export type AdminGetUserResponseBody$Outbound = {
  active: boolean;
  admin: boolean;
  api_key_count: number;
  approved_by: ApprovedBy$Outbound | null;
  associated_accounts?: Array<any> | undefined;
  avatar_template: string;
  badge_count: number;
  bounce_score: number | null;
  can_activate: boolean;
  can_be_anonymized: boolean;
  can_be_deleted: boolean;
  can_be_merged: boolean;
  can_deactivate: boolean;
  can_delete_all_posts: boolean;
  can_delete_sso_record: boolean;
  can_disable_second_factor: boolean;
  can_grant_admin: boolean;
  can_grant_moderation: boolean;
  can_impersonate: boolean;
  can_revoke_admin: boolean;
  can_revoke_moderation: boolean;
  can_send_activation_email: boolean;
  can_view_action_logs: boolean;
  created_at: string;
  created_at_age: number | null;
  days_visited: number;
  external_ids: AdminGetUserExternalIds$Outbound;
  flags_given_count: number;
  flags_received_count: number;
  full_suspend_reason: string | null;
  groups: Array<AdminGetUserGroups$Outbound>;
  id: number;
  ip_address: string;
  last_emailed_age: number | null;
  last_emailed_at: string | null;
  last_seen_age: number | null;
  last_seen_at: string | null;
  like_count: number;
  like_given_count: number;
  manual_locked_trust_level: string | null;
  moderator: boolean;
  name: string | null;
  next_penalty?: string | undefined;
  penalty_counts?: PenaltyCounts$Outbound | undefined;
  post_count: number;
  post_edits_count?: number | null | undefined;
  posts_read_count: number;
  primary_group_id: string | null;
  private_topics_count: number;
  registration_ip_address: string | null;
  reset_bounce_score_after: string | null;
  silence_reason: string | null;
  silenced_by: string | null;
  single_sign_on_record: string | null;
  staged: boolean;
  suspended_by: string | null;
  time_read: number;
  title: string | null;
  tl3_requirements?: Tl3Requirements$Outbound | undefined;
  topic_count: number;
  topics_entered: number;
  trust_level: number;
  username: string;
  warnings_received_count: number;
};

/** @internal */
export const AdminGetUserResponseBody$outboundSchema: z.ZodType<
  AdminGetUserResponseBody$Outbound,
  z.ZodTypeDef,
  AdminGetUserResponseBody
> = z.object({
  active: z.boolean(),
  admin: z.boolean(),
  apiKeyCount: z.number().int(),
  approvedBy: z.nullable(z.lazy(() => ApprovedBy$outboundSchema)),
  associatedAccounts: z.array(z.any()).optional(),
  avatarTemplate: z.string(),
  badgeCount: z.number().int(),
  bounceScore: z.nullable(z.number().int()),
  canActivate: z.boolean(),
  canBeAnonymized: z.boolean(),
  canBeDeleted: z.boolean(),
  canBeMerged: z.boolean(),
  canDeactivate: z.boolean(),
  canDeleteAllPosts: z.boolean(),
  canDeleteSsoRecord: z.boolean(),
  canDisableSecondFactor: z.boolean(),
  canGrantAdmin: z.boolean(),
  canGrantModeration: z.boolean(),
  canImpersonate: z.boolean(),
  canRevokeAdmin: z.boolean(),
  canRevokeModeration: z.boolean(),
  canSendActivationEmail: z.boolean(),
  canViewActionLogs: z.boolean(),
  createdAt: z.string(),
  createdAtAge: z.nullable(z.number()),
  daysVisited: z.number().int(),
  externalIds: z.lazy(() => AdminGetUserExternalIds$outboundSchema),
  flagsGivenCount: z.number().int(),
  flagsReceivedCount: z.number().int(),
  fullSuspendReason: z.nullable(z.string()),
  groups: z.array(z.lazy(() => AdminGetUserGroups$outboundSchema)),
  id: z.number().int(),
  ipAddress: z.string(),
  lastEmailedAge: z.nullable(z.number()),
  lastEmailedAt: z.nullable(z.string()),
  lastSeenAge: z.nullable(z.number()),
  lastSeenAt: z.nullable(z.string()),
  likeCount: z.number().int(),
  likeGivenCount: z.number().int(),
  manualLockedTrustLevel: z.nullable(z.string()),
  moderator: z.boolean(),
  name: z.nullable(z.string()),
  nextPenalty: z.string().optional(),
  penaltyCounts: z.lazy(() => PenaltyCounts$outboundSchema).optional(),
  postCount: z.number().int(),
  postEditsCount: z.nullable(z.number().int()).optional(),
  postsReadCount: z.number().int(),
  primaryGroupId: z.nullable(z.string()),
  privateTopicsCount: z.number().int(),
  registrationIpAddress: z.nullable(z.string()),
  resetBounceScoreAfter: z.nullable(z.string()),
  silenceReason: z.nullable(z.string()),
  silencedBy: z.nullable(z.string()),
  singleSignOnRecord: z.nullable(z.string()),
  staged: z.boolean(),
  suspendedBy: z.nullable(z.string()),
  timeRead: z.number().int(),
  title: z.nullable(z.string()),
  tl3Requirements: z.lazy(() => Tl3Requirements$outboundSchema).optional(),
  topicCount: z.number().int(),
  topicsEntered: z.number().int(),
  trustLevel: z.number().int(),
  username: z.string(),
  warningsReceivedCount: z.number().int(),
}).transform((v) => {
  return remap$(v, {
    apiKeyCount: "api_key_count",
    approvedBy: "approved_by",
    associatedAccounts: "associated_accounts",
    avatarTemplate: "avatar_template",
    badgeCount: "badge_count",
    bounceScore: "bounce_score",
    canActivate: "can_activate",
    canBeAnonymized: "can_be_anonymized",
    canBeDeleted: "can_be_deleted",
    canBeMerged: "can_be_merged",
    canDeactivate: "can_deactivate",
    canDeleteAllPosts: "can_delete_all_posts",
    canDeleteSsoRecord: "can_delete_sso_record",
    canDisableSecondFactor: "can_disable_second_factor",
    canGrantAdmin: "can_grant_admin",
    canGrantModeration: "can_grant_moderation",
    canImpersonate: "can_impersonate",
    canRevokeAdmin: "can_revoke_admin",
    canRevokeModeration: "can_revoke_moderation",
    canSendActivationEmail: "can_send_activation_email",
    canViewActionLogs: "can_view_action_logs",
    createdAt: "created_at",
    createdAtAge: "created_at_age",
    daysVisited: "days_visited",
    externalIds: "external_ids",
    flagsGivenCount: "flags_given_count",
    flagsReceivedCount: "flags_received_count",
    fullSuspendReason: "full_suspend_reason",
    ipAddress: "ip_address",
    lastEmailedAge: "last_emailed_age",
    lastEmailedAt: "last_emailed_at",
    lastSeenAge: "last_seen_age",
    lastSeenAt: "last_seen_at",
    likeCount: "like_count",
    likeGivenCount: "like_given_count",
    manualLockedTrustLevel: "manual_locked_trust_level",
    nextPenalty: "next_penalty",
    penaltyCounts: "penalty_counts",
    postCount: "post_count",
    postEditsCount: "post_edits_count",
    postsReadCount: "posts_read_count",
    primaryGroupId: "primary_group_id",
    privateTopicsCount: "private_topics_count",
    registrationIpAddress: "registration_ip_address",
    resetBounceScoreAfter: "reset_bounce_score_after",
    silenceReason: "silence_reason",
    silencedBy: "silenced_by",
    singleSignOnRecord: "single_sign_on_record",
    suspendedBy: "suspended_by",
    timeRead: "time_read",
    tl3Requirements: "tl3_requirements",
    topicCount: "topic_count",
    topicsEntered: "topics_entered",
    trustLevel: "trust_level",
    warningsReceivedCount: "warnings_received_count",
  });
});

/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export namespace AdminGetUserResponseBody$ {
  /** @deprecated use `AdminGetUserResponseBody$inboundSchema` instead. */
  export const inboundSchema = AdminGetUserResponseBody$inboundSchema;
  /** @deprecated use `AdminGetUserResponseBody$outboundSchema` instead. */
  export const outboundSchema = AdminGetUserResponseBody$outboundSchema;
  /** @deprecated use `AdminGetUserResponseBody$Outbound` instead. */
  export type Outbound = AdminGetUserResponseBody$Outbound;
}