/*
 * 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 ListUserBadgesRequest = {
  username: string;
};

export type ListUserBadgesBadgeTypes = {
  id: number;
  name: string;
  sortOrder: number;
};

export type ListUserBadgesBadges = {
  allowTitle: boolean;
  badgeGroupingId: number;
  badgeTypeId: number;
  description: string;
  enabled: boolean;
  grantCount: number;
  icon: string;
  id: number;
  imageUrl: string | null;
  listable: boolean;
  manuallyGrantable: boolean;
  multipleGrant: boolean;
  name: string;
  slug: string;
  system: boolean;
};

export type GrantedBies = {
  admin: boolean;
  avatarTemplate: string;
  flairName: string | null;
  id: number;
  moderator: boolean;
  name: string;
  trustLevel: number;
  username: string;
};

export type UserBadges = {
  badgeId: number;
  canFavorite: boolean;
  grantedAt: string;
  grantedById: number;
  groupingPosition: number;
  id: number;
  isFavorite: string | null;
};

/**
 * success response
 */
export type ListUserBadgesResponseBody = {
  badgeTypes?: Array<ListUserBadgesBadgeTypes> | undefined;
  badges?: Array<ListUserBadgesBadges> | undefined;
  grantedBies?: Array<GrantedBies> | undefined;
  userBadges: Array<UserBadges>;
};

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

/** @internal */
export type ListUserBadgesRequest$Outbound = {
  username: string;
};

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

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

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

/** @internal */
export type ListUserBadgesBadgeTypes$Outbound = {
  id: number;
  name: string;
  sort_order: number;
};

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

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

/** @internal */
export const ListUserBadgesBadges$inboundSchema: z.ZodType<
  ListUserBadgesBadges,
  z.ZodTypeDef,
  unknown
> = z.object({
  allow_title: z.boolean(),
  badge_grouping_id: z.number().int(),
  badge_type_id: z.number().int(),
  description: z.string(),
  enabled: z.boolean(),
  grant_count: z.number().int(),
  icon: z.string(),
  id: z.number().int(),
  image_url: z.nullable(z.string()),
  listable: z.boolean(),
  manually_grantable: z.boolean(),
  multiple_grant: z.boolean(),
  name: z.string(),
  slug: z.string(),
  system: z.boolean(),
}).transform((v) => {
  return remap$(v, {
    "allow_title": "allowTitle",
    "badge_grouping_id": "badgeGroupingId",
    "badge_type_id": "badgeTypeId",
    "grant_count": "grantCount",
    "image_url": "imageUrl",
    "manually_grantable": "manuallyGrantable",
    "multiple_grant": "multipleGrant",
  });
});

/** @internal */
export type ListUserBadgesBadges$Outbound = {
  allow_title: boolean;
  badge_grouping_id: number;
  badge_type_id: number;
  description: string;
  enabled: boolean;
  grant_count: number;
  icon: string;
  id: number;
  image_url: string | null;
  listable: boolean;
  manually_grantable: boolean;
  multiple_grant: boolean;
  name: string;
  slug: string;
  system: boolean;
};

/** @internal */
export const ListUserBadgesBadges$outboundSchema: z.ZodType<
  ListUserBadgesBadges$Outbound,
  z.ZodTypeDef,
  ListUserBadgesBadges
> = z.object({
  allowTitle: z.boolean(),
  badgeGroupingId: z.number().int(),
  badgeTypeId: z.number().int(),
  description: z.string(),
  enabled: z.boolean(),
  grantCount: z.number().int(),
  icon: z.string(),
  id: z.number().int(),
  imageUrl: z.nullable(z.string()),
  listable: z.boolean(),
  manuallyGrantable: z.boolean(),
  multipleGrant: z.boolean(),
  name: z.string(),
  slug: z.string(),
  system: z.boolean(),
}).transform((v) => {
  return remap$(v, {
    allowTitle: "allow_title",
    badgeGroupingId: "badge_grouping_id",
    badgeTypeId: "badge_type_id",
    grantCount: "grant_count",
    imageUrl: "image_url",
    manuallyGrantable: "manually_grantable",
    multipleGrant: "multiple_grant",
  });
});

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

/** @internal */
export const GrantedBies$inboundSchema: z.ZodType<
  GrantedBies,
  z.ZodTypeDef,
  unknown
> = z.object({
  admin: z.boolean(),
  avatar_template: z.string(),
  flair_name: z.nullable(z.string()),
  id: z.number().int(),
  moderator: z.boolean(),
  name: z.string(),
  trust_level: z.number().int(),
  username: z.string(),
}).transform((v) => {
  return remap$(v, {
    "avatar_template": "avatarTemplate",
    "flair_name": "flairName",
    "trust_level": "trustLevel",
  });
});

/** @internal */
export type GrantedBies$Outbound = {
  admin: boolean;
  avatar_template: string;
  flair_name: string | null;
  id: number;
  moderator: boolean;
  name: string;
  trust_level: number;
  username: string;
};

/** @internal */
export const GrantedBies$outboundSchema: z.ZodType<
  GrantedBies$Outbound,
  z.ZodTypeDef,
  GrantedBies
> = z.object({
  admin: z.boolean(),
  avatarTemplate: z.string(),
  flairName: z.nullable(z.string()),
  id: z.number().int(),
  moderator: z.boolean(),
  name: z.string(),
  trustLevel: z.number().int(),
  username: z.string(),
}).transform((v) => {
  return remap$(v, {
    avatarTemplate: "avatar_template",
    flairName: "flair_name",
    trustLevel: "trust_level",
  });
});

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

/** @internal */
export const UserBadges$inboundSchema: z.ZodType<
  UserBadges,
  z.ZodTypeDef,
  unknown
> = z.object({
  badge_id: z.number().int(),
  can_favorite: z.boolean(),
  granted_at: z.string(),
  granted_by_id: z.number().int(),
  grouping_position: z.number().int(),
  id: z.number().int(),
  is_favorite: z.nullable(z.string()),
}).transform((v) => {
  return remap$(v, {
    "badge_id": "badgeId",
    "can_favorite": "canFavorite",
    "granted_at": "grantedAt",
    "granted_by_id": "grantedById",
    "grouping_position": "groupingPosition",
    "is_favorite": "isFavorite",
  });
});

/** @internal */
export type UserBadges$Outbound = {
  badge_id: number;
  can_favorite: boolean;
  granted_at: string;
  granted_by_id: number;
  grouping_position: number;
  id: number;
  is_favorite: string | null;
};

/** @internal */
export const UserBadges$outboundSchema: z.ZodType<
  UserBadges$Outbound,
  z.ZodTypeDef,
  UserBadges
> = z.object({
  badgeId: z.number().int(),
  canFavorite: z.boolean(),
  grantedAt: z.string(),
  grantedById: z.number().int(),
  groupingPosition: z.number().int(),
  id: z.number().int(),
  isFavorite: z.nullable(z.string()),
}).transform((v) => {
  return remap$(v, {
    badgeId: "badge_id",
    canFavorite: "can_favorite",
    grantedAt: "granted_at",
    grantedById: "granted_by_id",
    groupingPosition: "grouping_position",
    isFavorite: "is_favorite",
  });
});

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

/** @internal */
export const ListUserBadgesResponseBody$inboundSchema: z.ZodType<
  ListUserBadgesResponseBody,
  z.ZodTypeDef,
  unknown
> = z.object({
  badge_types: z.array(z.lazy(() => ListUserBadgesBadgeTypes$inboundSchema))
    .optional(),
  badges: z.array(z.lazy(() => ListUserBadgesBadges$inboundSchema)).optional(),
  granted_bies: z.array(z.lazy(() => GrantedBies$inboundSchema)).optional(),
  user_badges: z.array(z.lazy(() => UserBadges$inboundSchema)),
}).transform((v) => {
  return remap$(v, {
    "badge_types": "badgeTypes",
    "granted_bies": "grantedBies",
    "user_badges": "userBadges",
  });
});

/** @internal */
export type ListUserBadgesResponseBody$Outbound = {
  badge_types?: Array<ListUserBadgesBadgeTypes$Outbound> | undefined;
  badges?: Array<ListUserBadgesBadges$Outbound> | undefined;
  granted_bies?: Array<GrantedBies$Outbound> | undefined;
  user_badges: Array<UserBadges$Outbound>;
};

/** @internal */
export const ListUserBadgesResponseBody$outboundSchema: z.ZodType<
  ListUserBadgesResponseBody$Outbound,
  z.ZodTypeDef,
  ListUserBadgesResponseBody
> = z.object({
  badgeTypes: z.array(z.lazy(() => ListUserBadgesBadgeTypes$outboundSchema))
    .optional(),
  badges: z.array(z.lazy(() => ListUserBadgesBadges$outboundSchema)).optional(),
  grantedBies: z.array(z.lazy(() => GrantedBies$outboundSchema)).optional(),
  userBadges: z.array(z.lazy(() => UserBadges$outboundSchema)),
}).transform((v) => {
  return remap$(v, {
    badgeTypes: "badge_types",
    grantedBies: "granted_bies",
    userBadges: "user_badges",
  });
});

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