/*
 * 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 Triggers = {
  none: number;
  postAction: number;
  postRevision: number;
  trustLevelChange: number;
  userChange: number;
};

export type AdminBadges = {
  badgeGroupingIds: Array<any>;
  badgeIds: Array<any>;
  badgeTypeIds: Array<any>;
  protectedSystemFields: Array<any>;
  triggers: Triggers;
};

export type BadgeGroupings = {
  description: string | null;
  id: number;
  name: string;
  position: number;
  system: boolean;
};

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

export type Badges = {
  allowTitle: boolean;
  autoRevoke: boolean;
  badgeGroupingId: number;
  badgeTypeId: number;
  description: string;
  enabled: boolean;
  grantCount: number;
  i18nName?: string | null | undefined;
  icon: string;
  id: number;
  imageUrl: string | null;
  listable: boolean;
  longDescription: string;
  manuallyGrantable: boolean;
  multipleGrant: boolean;
  name: string;
  query: string | null;
  showPosts: boolean;
  slug: string;
  system: boolean;
  targetPosts: boolean;
  trigger: number | null;
};

/**
 * success response
 */
export type AdminListBadgesResponseBody = {
  adminBadges: AdminBadges;
  badgeGroupings: Array<BadgeGroupings>;
  badgeTypes: Array<BadgeTypes>;
  badges: Array<Badges>;
};

/** @internal */
export const Triggers$inboundSchema: z.ZodType<
  Triggers,
  z.ZodTypeDef,
  unknown
> = z.object({
  none: z.number().int(),
  post_action: z.number().int(),
  post_revision: z.number().int(),
  trust_level_change: z.number().int(),
  user_change: z.number().int(),
}).transform((v) => {
  return remap$(v, {
    "post_action": "postAction",
    "post_revision": "postRevision",
    "trust_level_change": "trustLevelChange",
    "user_change": "userChange",
  });
});

/** @internal */
export type Triggers$Outbound = {
  none: number;
  post_action: number;
  post_revision: number;
  trust_level_change: number;
  user_change: number;
};

/** @internal */
export const Triggers$outboundSchema: z.ZodType<
  Triggers$Outbound,
  z.ZodTypeDef,
  Triggers
> = z.object({
  none: z.number().int(),
  postAction: z.number().int(),
  postRevision: z.number().int(),
  trustLevelChange: z.number().int(),
  userChange: z.number().int(),
}).transform((v) => {
  return remap$(v, {
    postAction: "post_action",
    postRevision: "post_revision",
    trustLevelChange: "trust_level_change",
    userChange: "user_change",
  });
});

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

/** @internal */
export const AdminBadges$inboundSchema: z.ZodType<
  AdminBadges,
  z.ZodTypeDef,
  unknown
> = z.object({
  badge_grouping_ids: z.array(z.any()),
  badge_ids: z.array(z.any()),
  badge_type_ids: z.array(z.any()),
  protected_system_fields: z.array(z.any()),
  triggers: z.lazy(() => Triggers$inboundSchema),
}).transform((v) => {
  return remap$(v, {
    "badge_grouping_ids": "badgeGroupingIds",
    "badge_ids": "badgeIds",
    "badge_type_ids": "badgeTypeIds",
    "protected_system_fields": "protectedSystemFields",
  });
});

/** @internal */
export type AdminBadges$Outbound = {
  badge_grouping_ids: Array<any>;
  badge_ids: Array<any>;
  badge_type_ids: Array<any>;
  protected_system_fields: Array<any>;
  triggers: Triggers$Outbound;
};

/** @internal */
export const AdminBadges$outboundSchema: z.ZodType<
  AdminBadges$Outbound,
  z.ZodTypeDef,
  AdminBadges
> = z.object({
  badgeGroupingIds: z.array(z.any()),
  badgeIds: z.array(z.any()),
  badgeTypeIds: z.array(z.any()),
  protectedSystemFields: z.array(z.any()),
  triggers: z.lazy(() => Triggers$outboundSchema),
}).transform((v) => {
  return remap$(v, {
    badgeGroupingIds: "badge_grouping_ids",
    badgeIds: "badge_ids",
    badgeTypeIds: "badge_type_ids",
    protectedSystemFields: "protected_system_fields",
  });
});

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

/** @internal */
export const BadgeGroupings$inboundSchema: z.ZodType<
  BadgeGroupings,
  z.ZodTypeDef,
  unknown
> = z.object({
  description: z.nullable(z.string()),
  id: z.number().int(),
  name: z.string(),
  position: z.number().int(),
  system: z.boolean(),
});

/** @internal */
export type BadgeGroupings$Outbound = {
  description: string | null;
  id: number;
  name: string;
  position: number;
  system: boolean;
};

/** @internal */
export const BadgeGroupings$outboundSchema: z.ZodType<
  BadgeGroupings$Outbound,
  z.ZodTypeDef,
  BadgeGroupings
> = z.object({
  description: z.nullable(z.string()),
  id: z.number().int(),
  name: z.string(),
  position: z.number().int(),
  system: z.boolean(),
});

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

/** @internal */
export const BadgeTypes$inboundSchema: z.ZodType<
  BadgeTypes,
  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 BadgeTypes$Outbound = {
  id: number;
  name: string;
  sort_order: number;
};

/** @internal */
export const BadgeTypes$outboundSchema: z.ZodType<
  BadgeTypes$Outbound,
  z.ZodTypeDef,
  BadgeTypes
> = 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 BadgeTypes$ {
  /** @deprecated use `BadgeTypes$inboundSchema` instead. */
  export const inboundSchema = BadgeTypes$inboundSchema;
  /** @deprecated use `BadgeTypes$outboundSchema` instead. */
  export const outboundSchema = BadgeTypes$outboundSchema;
  /** @deprecated use `BadgeTypes$Outbound` instead. */
  export type Outbound = BadgeTypes$Outbound;
}

/** @internal */
export const Badges$inboundSchema: z.ZodType<Badges, z.ZodTypeDef, unknown> = z
  .object({
    allow_title: z.boolean(),
    auto_revoke: 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(),
    i18n_name: z.nullable(z.string()).optional(),
    icon: z.string(),
    id: z.number().int(),
    image_url: z.nullable(z.string()),
    listable: z.boolean(),
    long_description: z.string(),
    manually_grantable: z.boolean(),
    multiple_grant: z.boolean(),
    name: z.string(),
    query: z.nullable(z.string()),
    show_posts: z.boolean(),
    slug: z.string(),
    system: z.boolean(),
    target_posts: z.boolean(),
    trigger: z.nullable(z.number().int()),
  }).transform((v) => {
    return remap$(v, {
      "allow_title": "allowTitle",
      "auto_revoke": "autoRevoke",
      "badge_grouping_id": "badgeGroupingId",
      "badge_type_id": "badgeTypeId",
      "grant_count": "grantCount",
      "i18n_name": "i18nName",
      "image_url": "imageUrl",
      "long_description": "longDescription",
      "manually_grantable": "manuallyGrantable",
      "multiple_grant": "multipleGrant",
      "show_posts": "showPosts",
      "target_posts": "targetPosts",
    });
  });

/** @internal */
export type Badges$Outbound = {
  allow_title: boolean;
  auto_revoke: boolean;
  badge_grouping_id: number;
  badge_type_id: number;
  description: string;
  enabled: boolean;
  grant_count: number;
  i18n_name?: string | null | undefined;
  icon: string;
  id: number;
  image_url: string | null;
  listable: boolean;
  long_description: string;
  manually_grantable: boolean;
  multiple_grant: boolean;
  name: string;
  query: string | null;
  show_posts: boolean;
  slug: string;
  system: boolean;
  target_posts: boolean;
  trigger: number | null;
};

/** @internal */
export const Badges$outboundSchema: z.ZodType<
  Badges$Outbound,
  z.ZodTypeDef,
  Badges
> = z.object({
  allowTitle: z.boolean(),
  autoRevoke: z.boolean(),
  badgeGroupingId: z.number().int(),
  badgeTypeId: z.number().int(),
  description: z.string(),
  enabled: z.boolean(),
  grantCount: z.number().int(),
  i18nName: z.nullable(z.string()).optional(),
  icon: z.string(),
  id: z.number().int(),
  imageUrl: z.nullable(z.string()),
  listable: z.boolean(),
  longDescription: z.string(),
  manuallyGrantable: z.boolean(),
  multipleGrant: z.boolean(),
  name: z.string(),
  query: z.nullable(z.string()),
  showPosts: z.boolean(),
  slug: z.string(),
  system: z.boolean(),
  targetPosts: z.boolean(),
  trigger: z.nullable(z.number().int()),
}).transform((v) => {
  return remap$(v, {
    allowTitle: "allow_title",
    autoRevoke: "auto_revoke",
    badgeGroupingId: "badge_grouping_id",
    badgeTypeId: "badge_type_id",
    grantCount: "grant_count",
    i18nName: "i18n_name",
    imageUrl: "image_url",
    longDescription: "long_description",
    manuallyGrantable: "manually_grantable",
    multipleGrant: "multiple_grant",
    showPosts: "show_posts",
    targetPosts: "target_posts",
  });
});

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

/** @internal */
export const AdminListBadgesResponseBody$inboundSchema: z.ZodType<
  AdminListBadgesResponseBody,
  z.ZodTypeDef,
  unknown
> = z.object({
  admin_badges: z.lazy(() => AdminBadges$inboundSchema),
  badge_groupings: z.array(z.lazy(() => BadgeGroupings$inboundSchema)),
  badge_types: z.array(z.lazy(() => BadgeTypes$inboundSchema)),
  badges: z.array(z.lazy(() => Badges$inboundSchema)),
}).transform((v) => {
  return remap$(v, {
    "admin_badges": "adminBadges",
    "badge_groupings": "badgeGroupings",
    "badge_types": "badgeTypes",
  });
});

/** @internal */
export type AdminListBadgesResponseBody$Outbound = {
  admin_badges: AdminBadges$Outbound;
  badge_groupings: Array<BadgeGroupings$Outbound>;
  badge_types: Array<BadgeTypes$Outbound>;
  badges: Array<Badges$Outbound>;
};

/** @internal */
export const AdminListBadgesResponseBody$outboundSchema: z.ZodType<
  AdminListBadgesResponseBody$Outbound,
  z.ZodTypeDef,
  AdminListBadgesResponseBody
> = z.object({
  adminBadges: z.lazy(() => AdminBadges$outboundSchema),
  badgeGroupings: z.array(z.lazy(() => BadgeGroupings$outboundSchema)),
  badgeTypes: z.array(z.lazy(() => BadgeTypes$outboundSchema)),
  badges: z.array(z.lazy(() => Badges$outboundSchema)),
}).transform((v) => {
  return remap$(v, {
    adminBadges: "admin_badges",
    badgeGroupings: "badge_groupings",
    badgeTypes: "badge_types",
  });
});

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