@parke.dev/discoursejs 0.10.2

package/src/sdk/models/operations/updatecategory.ts

@@ -0,0 +1,760 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { remap as remap$ } from "../../../lib/primitives.js";
+import { collectExtraKeys as collectExtraKeys$ } from "../../../lib/schemas.js";
+
+export type UpdateCategoryPermissions = {
+  everyone?: number | undefined;
+  staff?: number | undefined;
+  additionalProperties: { [k: string]: any };
+};
+
+export type UpdateCategoryRequestBody = {
+  allowBadges?: boolean | undefined;
+  color?: string | undefined;
+  formTemplateIds?: Array<any> | undefined;
+  name: string;
+  parentCategoryId?: number | undefined;
+  permissions?: UpdateCategoryPermissions | undefined;
+  searchPriority?: number | undefined;
+  slug?: string | undefined;
+  textColor?: string | undefined;
+  topicFeaturedLinksAllowed?: boolean | undefined;
+};
+
+export type UpdateCategoryRequest = {
+  requestBody?: UpdateCategoryRequestBody | undefined;
+  id: number;
+};
+
+export type UpdateCategoryCustomFields = {};
+
+export type UpdateCategoryGroupPermissions = {
+  groupName: string;
+  permissionType: number;
+};
+
+export type UpdateCategoryRequiredTagGroups = {
+  minCount: number;
+  name: string;
+};
+
+export type UpdateCategoryCategory = {
+  allTopicsWiki: boolean;
+  allowBadges: boolean;
+  allowGlobalTags?: boolean | undefined;
+  allowUnlimitedOwnerEditsOnFirstPost: boolean;
+  allowedTagGroups?: Array<any> | undefined;
+  allowedTags?: Array<any> | undefined;
+  autoCloseBasedOnLastPost: boolean;
+  autoCloseHours: string | null;
+  availableGroups: Array<any>;
+  canDelete: boolean;
+  canEdit: boolean;
+  categorySetting?: any | undefined;
+  color: string;
+  customFields: UpdateCategoryCustomFields;
+  defaultListFilter: string;
+  defaultSlowModeSeconds: string | null;
+  defaultTopPeriod: string;
+  defaultView: string | null;
+  description: string | null;
+  descriptionExcerpt: string | null;
+  descriptionText: string | null;
+  emailIn: string | null;
+  emailInAllowStrangers: boolean;
+  formTemplateIds: Array<any>;
+  groupPermissions: Array<UpdateCategoryGroupPermissions>;
+  hasChildren: boolean | null;
+  id: number;
+  mailinglistMirror: boolean;
+  minimumRequiredTags: number;
+  name: string;
+  navigateToFirstPostAfterRead: boolean;
+  notificationLevel: number;
+  numFeaturedTopics: number;
+  permission: number | null;
+  position: number;
+  postCount: number;
+  readOnlyBanner: string | null;
+  readRestricted: boolean;
+  requiredTagGroups: Array<UpdateCategoryRequiredTagGroups>;
+  searchPriority: number;
+  showSubcategoryList: boolean;
+  slug: string;
+  sortAscending: string | null;
+  sortOrder: string | null;
+  subcategoryListStyle: string;
+  textColor: string;
+  topicCount: number;
+  topicFeaturedLinkAllowed: boolean;
+  topicTemplate: string | null;
+  topicUrl: string | null;
+  uploadedBackground: string | null;
+  uploadedBackgroundDark: string | null;
+  uploadedLogo: string | null;
+  uploadedLogoDark: string | null;
+};
+
+/**
+ * success response
+ */
+export type UpdateCategoryResponseBody = {
+  category: UpdateCategoryCategory;
+  success: string;
+};
+
+/** @internal */
+export const UpdateCategoryPermissions$inboundSchema: z.ZodType<
+  UpdateCategoryPermissions,
+  z.ZodTypeDef,
+  unknown
+> = collectExtraKeys$(
+  z.object({
+    everyone: z.number().int().optional(),
+    staff: z.number().int().optional(),
+  }).catchall(z.any()),
+  "additionalProperties",
+);
+
+/** @internal */
+export type UpdateCategoryPermissions$Outbound = {
+  everyone?: number | undefined;
+  staff?: number | undefined;
+  [additionalProperties: string]: unknown;
+};
+
+/** @internal */
+export const UpdateCategoryPermissions$outboundSchema: z.ZodType<
+  UpdateCategoryPermissions$Outbound,
+  z.ZodTypeDef,
+  UpdateCategoryPermissions
+> = z.object({
+  additionalProperties: z.record(z.any()),
+
+  everyone: z.number().int().optional(),
+  staff: z.number().int().optional(),
+}).transform((v) => {
+  return {
+    ...v.additionalProperties,
+    ...remap$(v, {
+      additionalProperties: null,
+    }),
+  };
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace UpdateCategoryPermissions$ {
+  /** @deprecated use `UpdateCategoryPermissions$inboundSchema` instead. */
+  export const inboundSchema = UpdateCategoryPermissions$inboundSchema;
+  /** @deprecated use `UpdateCategoryPermissions$outboundSchema` instead. */
+  export const outboundSchema = UpdateCategoryPermissions$outboundSchema;
+  /** @deprecated use `UpdateCategoryPermissions$Outbound` instead. */
+  export type Outbound = UpdateCategoryPermissions$Outbound;
+}
+
+/** @internal */
+export const UpdateCategoryRequestBody$inboundSchema: z.ZodType<
+  UpdateCategoryRequestBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  allow_badges: z.boolean().optional(),
+  color: z.string().optional(),
+  form_template_ids: z.array(z.any()).optional(),
+  name: z.string(),
+  parent_category_id: z.number().int().optional(),
+  permissions: z.lazy(() => UpdateCategoryPermissions$inboundSchema).optional(),
+  search_priority: z.number().int().optional(),
+  slug: z.string().optional(),
+  text_color: z.string().optional(),
+  topic_featured_links_allowed: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "allow_badges": "allowBadges",
+    "form_template_ids": "formTemplateIds",
+    "parent_category_id": "parentCategoryId",
+    "search_priority": "searchPriority",
+    "text_color": "textColor",
+    "topic_featured_links_allowed": "topicFeaturedLinksAllowed",
+  });
+});
+
+/** @internal */
+export type UpdateCategoryRequestBody$Outbound = {
+  allow_badges?: boolean | undefined;
+  color?: string | undefined;
+  form_template_ids?: Array<any> | undefined;
+  name: string;
+  parent_category_id?: number | undefined;
+  permissions?: UpdateCategoryPermissions$Outbound | undefined;
+  search_priority?: number | undefined;
+  slug?: string | undefined;
+  text_color?: string | undefined;
+  topic_featured_links_allowed?: boolean | undefined;
+};
+
+/** @internal */
+export const UpdateCategoryRequestBody$outboundSchema: z.ZodType<
+  UpdateCategoryRequestBody$Outbound,
+  z.ZodTypeDef,
+  UpdateCategoryRequestBody
+> = z.object({
+  allowBadges: z.boolean().optional(),
+  color: z.string().optional(),
+  formTemplateIds: z.array(z.any()).optional(),
+  name: z.string(),
+  parentCategoryId: z.number().int().optional(),
+  permissions: z.lazy(() => UpdateCategoryPermissions$outboundSchema)
+    .optional(),
+  searchPriority: z.number().int().optional(),
+  slug: z.string().optional(),
+  textColor: z.string().optional(),
+  topicFeaturedLinksAllowed: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    allowBadges: "allow_badges",
+    formTemplateIds: "form_template_ids",
+    parentCategoryId: "parent_category_id",
+    searchPriority: "search_priority",
+    textColor: "text_color",
+    topicFeaturedLinksAllowed: "topic_featured_links_allowed",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace UpdateCategoryRequestBody$ {
+  /** @deprecated use `UpdateCategoryRequestBody$inboundSchema` instead. */
+  export const inboundSchema = UpdateCategoryRequestBody$inboundSchema;
+  /** @deprecated use `UpdateCategoryRequestBody$outboundSchema` instead. */
+  export const outboundSchema = UpdateCategoryRequestBody$outboundSchema;
+  /** @deprecated use `UpdateCategoryRequestBody$Outbound` instead. */
+  export type Outbound = UpdateCategoryRequestBody$Outbound;
+}
+
+/** @internal */
+export const UpdateCategoryRequest$inboundSchema: z.ZodType<
+  UpdateCategoryRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  RequestBody: z.lazy(() => UpdateCategoryRequestBody$inboundSchema).optional(),
+  id: z.number().int(),
+}).transform((v) => {
+  return remap$(v, {
+    "RequestBody": "requestBody",
+  });
+});
+
+/** @internal */
+export type UpdateCategoryRequest$Outbound = {
+  RequestBody?: UpdateCategoryRequestBody$Outbound | undefined;
+  id: number;
+};
+
+/** @internal */
+export const UpdateCategoryRequest$outboundSchema: z.ZodType<
+  UpdateCategoryRequest$Outbound,
+  z.ZodTypeDef,
+  UpdateCategoryRequest
+> = z.object({
+  requestBody: z.lazy(() => UpdateCategoryRequestBody$outboundSchema)
+    .optional(),
+  id: z.number().int(),
+}).transform((v) => {
+  return remap$(v, {
+    requestBody: "RequestBody",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace UpdateCategoryRequest$ {
+  /** @deprecated use `UpdateCategoryRequest$inboundSchema` instead. */
+  export const inboundSchema = UpdateCategoryRequest$inboundSchema;
+  /** @deprecated use `UpdateCategoryRequest$outboundSchema` instead. */
+  export const outboundSchema = UpdateCategoryRequest$outboundSchema;
+  /** @deprecated use `UpdateCategoryRequest$Outbound` instead. */
+  export type Outbound = UpdateCategoryRequest$Outbound;
+}
+
+/** @internal */
+export const UpdateCategoryCustomFields$inboundSchema: z.ZodType<
+  UpdateCategoryCustomFields,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+/** @internal */
+export type UpdateCategoryCustomFields$Outbound = {};
+
+/** @internal */
+export const UpdateCategoryCustomFields$outboundSchema: z.ZodType<
+  UpdateCategoryCustomFields$Outbound,
+  z.ZodTypeDef,
+  UpdateCategoryCustomFields
+> = 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 UpdateCategoryCustomFields$ {
+  /** @deprecated use `UpdateCategoryCustomFields$inboundSchema` instead. */
+  export const inboundSchema = UpdateCategoryCustomFields$inboundSchema;
+  /** @deprecated use `UpdateCategoryCustomFields$outboundSchema` instead. */
+  export const outboundSchema = UpdateCategoryCustomFields$outboundSchema;
+  /** @deprecated use `UpdateCategoryCustomFields$Outbound` instead. */
+  export type Outbound = UpdateCategoryCustomFields$Outbound;
+}
+
+/** @internal */
+export const UpdateCategoryGroupPermissions$inboundSchema: z.ZodType<
+  UpdateCategoryGroupPermissions,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  group_name: z.string(),
+  permission_type: z.number().int(),
+}).transform((v) => {
+  return remap$(v, {
+    "group_name": "groupName",
+    "permission_type": "permissionType",
+  });
+});
+
+/** @internal */
+export type UpdateCategoryGroupPermissions$Outbound = {
+  group_name: string;
+  permission_type: number;
+};
+
+/** @internal */
+export const UpdateCategoryGroupPermissions$outboundSchema: z.ZodType<
+  UpdateCategoryGroupPermissions$Outbound,
+  z.ZodTypeDef,
+  UpdateCategoryGroupPermissions
+> = z.object({
+  groupName: z.string(),
+  permissionType: z.number().int(),
+}).transform((v) => {
+  return remap$(v, {
+    groupName: "group_name",
+    permissionType: "permission_type",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace UpdateCategoryGroupPermissions$ {
+  /** @deprecated use `UpdateCategoryGroupPermissions$inboundSchema` instead. */
+  export const inboundSchema = UpdateCategoryGroupPermissions$inboundSchema;
+  /** @deprecated use `UpdateCategoryGroupPermissions$outboundSchema` instead. */
+  export const outboundSchema = UpdateCategoryGroupPermissions$outboundSchema;
+  /** @deprecated use `UpdateCategoryGroupPermissions$Outbound` instead. */
+  export type Outbound = UpdateCategoryGroupPermissions$Outbound;
+}
+
+/** @internal */
+export const UpdateCategoryRequiredTagGroups$inboundSchema: z.ZodType<
+  UpdateCategoryRequiredTagGroups,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  min_count: z.number().int(),
+  name: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "min_count": "minCount",
+  });
+});
+
+/** @internal */
+export type UpdateCategoryRequiredTagGroups$Outbound = {
+  min_count: number;
+  name: string;
+};
+
+/** @internal */
+export const UpdateCategoryRequiredTagGroups$outboundSchema: z.ZodType<
+  UpdateCategoryRequiredTagGroups$Outbound,
+  z.ZodTypeDef,
+  UpdateCategoryRequiredTagGroups
+> = z.object({
+  minCount: z.number().int(),
+  name: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    minCount: "min_count",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace UpdateCategoryRequiredTagGroups$ {
+  /** @deprecated use `UpdateCategoryRequiredTagGroups$inboundSchema` instead. */
+  export const inboundSchema = UpdateCategoryRequiredTagGroups$inboundSchema;
+  /** @deprecated use `UpdateCategoryRequiredTagGroups$outboundSchema` instead. */
+  export const outboundSchema = UpdateCategoryRequiredTagGroups$outboundSchema;
+  /** @deprecated use `UpdateCategoryRequiredTagGroups$Outbound` instead. */
+  export type Outbound = UpdateCategoryRequiredTagGroups$Outbound;
+}
+
+/** @internal */
+export const UpdateCategoryCategory$inboundSchema: z.ZodType<
+  UpdateCategoryCategory,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  all_topics_wiki: z.boolean(),
+  allow_badges: z.boolean(),
+  allow_global_tags: z.boolean().optional(),
+  allow_unlimited_owner_edits_on_first_post: z.boolean(),
+  allowed_tag_groups: z.array(z.any()).optional(),
+  allowed_tags: z.array(z.any()).optional(),
+  auto_close_based_on_last_post: z.boolean(),
+  auto_close_hours: z.nullable(z.string()),
+  available_groups: z.array(z.any()),
+  can_delete: z.boolean(),
+  can_edit: z.boolean(),
+  category_setting: z.any().optional(),
+  color: z.string(),
+  custom_fields: z.lazy(() => UpdateCategoryCustomFields$inboundSchema),
+  default_list_filter: z.string(),
+  default_slow_mode_seconds: z.nullable(z.string()),
+  default_top_period: z.string(),
+  default_view: z.nullable(z.string()),
+  description: z.nullable(z.string()),
+  description_excerpt: z.nullable(z.string()),
+  description_text: z.nullable(z.string()),
+  email_in: z.nullable(z.string()),
+  email_in_allow_strangers: z.boolean(),
+  form_template_ids: z.array(z.any()),
+  group_permissions: z.array(
+    z.lazy(() => UpdateCategoryGroupPermissions$inboundSchema),
+  ),
+  has_children: z.nullable(z.boolean()),
+  id: z.number().int(),
+  mailinglist_mirror: z.boolean(),
+  minimum_required_tags: z.number().int(),
+  name: z.string(),
+  navigate_to_first_post_after_read: z.boolean(),
+  notification_level: z.number().int(),
+  num_featured_topics: z.number().int(),
+  permission: z.nullable(z.number().int()),
+  position: z.number().int(),
+  post_count: z.number().int(),
+  read_only_banner: z.nullable(z.string()),
+  read_restricted: z.boolean(),
+  required_tag_groups: z.array(
+    z.lazy(() => UpdateCategoryRequiredTagGroups$inboundSchema),
+  ),
+  search_priority: z.number().int(),
+  show_subcategory_list: z.boolean(),
+  slug: z.string(),
+  sort_ascending: z.nullable(z.string()),
+  sort_order: z.nullable(z.string()),
+  subcategory_list_style: z.string(),
+  text_color: z.string(),
+  topic_count: z.number().int(),
+  topic_featured_link_allowed: z.boolean(),
+  topic_template: z.nullable(z.string()),
+  topic_url: z.nullable(z.string()),
+  uploaded_background: z.nullable(z.string()),
+  uploaded_background_dark: z.nullable(z.string()),
+  uploaded_logo: z.nullable(z.string()),
+  uploaded_logo_dark: z.nullable(z.string()),
+}).transform((v) => {
+  return remap$(v, {
+    "all_topics_wiki": "allTopicsWiki",
+    "allow_badges": "allowBadges",
+    "allow_global_tags": "allowGlobalTags",
+    "allow_unlimited_owner_edits_on_first_post":
+      "allowUnlimitedOwnerEditsOnFirstPost",
+    "allowed_tag_groups": "allowedTagGroups",
+    "allowed_tags": "allowedTags",
+    "auto_close_based_on_last_post": "autoCloseBasedOnLastPost",
+    "auto_close_hours": "autoCloseHours",
+    "available_groups": "availableGroups",
+    "can_delete": "canDelete",
+    "can_edit": "canEdit",
+    "category_setting": "categorySetting",
+    "custom_fields": "customFields",
+    "default_list_filter": "defaultListFilter",
+    "default_slow_mode_seconds": "defaultSlowModeSeconds",
+    "default_top_period": "defaultTopPeriod",
+    "default_view": "defaultView",
+    "description_excerpt": "descriptionExcerpt",
+    "description_text": "descriptionText",
+    "email_in": "emailIn",
+    "email_in_allow_strangers": "emailInAllowStrangers",
+    "form_template_ids": "formTemplateIds",
+    "group_permissions": "groupPermissions",
+    "has_children": "hasChildren",
+    "mailinglist_mirror": "mailinglistMirror",
+    "minimum_required_tags": "minimumRequiredTags",
+    "navigate_to_first_post_after_read": "navigateToFirstPostAfterRead",
+    "notification_level": "notificationLevel",
+    "num_featured_topics": "numFeaturedTopics",
+    "post_count": "postCount",
+    "read_only_banner": "readOnlyBanner",
+    "read_restricted": "readRestricted",
+    "required_tag_groups": "requiredTagGroups",
+    "search_priority": "searchPriority",
+    "show_subcategory_list": "showSubcategoryList",
+    "sort_ascending": "sortAscending",
+    "sort_order": "sortOrder",
+    "subcategory_list_style": "subcategoryListStyle",
+    "text_color": "textColor",
+    "topic_count": "topicCount",
+    "topic_featured_link_allowed": "topicFeaturedLinkAllowed",
+    "topic_template": "topicTemplate",
+    "topic_url": "topicUrl",
+    "uploaded_background": "uploadedBackground",
+    "uploaded_background_dark": "uploadedBackgroundDark",
+    "uploaded_logo": "uploadedLogo",
+    "uploaded_logo_dark": "uploadedLogoDark",
+  });
+});
+
+/** @internal */
+export type UpdateCategoryCategory$Outbound = {
+  all_topics_wiki: boolean;
+  allow_badges: boolean;
+  allow_global_tags?: boolean | undefined;
+  allow_unlimited_owner_edits_on_first_post: boolean;
+  allowed_tag_groups?: Array<any> | undefined;
+  allowed_tags?: Array<any> | undefined;
+  auto_close_based_on_last_post: boolean;
+  auto_close_hours: string | null;
+  available_groups: Array<any>;
+  can_delete: boolean;
+  can_edit: boolean;
+  category_setting?: any | undefined;
+  color: string;
+  custom_fields: UpdateCategoryCustomFields$Outbound;
+  default_list_filter: string;
+  default_slow_mode_seconds: string | null;
+  default_top_period: string;
+  default_view: string | null;
+  description: string | null;
+  description_excerpt: string | null;
+  description_text: string | null;
+  email_in: string | null;
+  email_in_allow_strangers: boolean;
+  form_template_ids: Array<any>;
+  group_permissions: Array<UpdateCategoryGroupPermissions$Outbound>;
+  has_children: boolean | null;
+  id: number;
+  mailinglist_mirror: boolean;
+  minimum_required_tags: number;
+  name: string;
+  navigate_to_first_post_after_read: boolean;
+  notification_level: number;
+  num_featured_topics: number;
+  permission: number | null;
+  position: number;
+  post_count: number;
+  read_only_banner: string | null;
+  read_restricted: boolean;
+  required_tag_groups: Array<UpdateCategoryRequiredTagGroups$Outbound>;
+  search_priority: number;
+  show_subcategory_list: boolean;
+  slug: string;
+  sort_ascending: string | null;
+  sort_order: string | null;
+  subcategory_list_style: string;
+  text_color: string;
+  topic_count: number;
+  topic_featured_link_allowed: boolean;
+  topic_template: string | null;
+  topic_url: string | null;
+  uploaded_background: string | null;
+  uploaded_background_dark: string | null;
+  uploaded_logo: string | null;
+  uploaded_logo_dark: string | null;
+};
+
+/** @internal */
+export const UpdateCategoryCategory$outboundSchema: z.ZodType<
+  UpdateCategoryCategory$Outbound,
+  z.ZodTypeDef,
+  UpdateCategoryCategory
+> = z.object({
+  allTopicsWiki: z.boolean(),
+  allowBadges: z.boolean(),
+  allowGlobalTags: z.boolean().optional(),
+  allowUnlimitedOwnerEditsOnFirstPost: z.boolean(),
+  allowedTagGroups: z.array(z.any()).optional(),
+  allowedTags: z.array(z.any()).optional(),
+  autoCloseBasedOnLastPost: z.boolean(),
+  autoCloseHours: z.nullable(z.string()),
+  availableGroups: z.array(z.any()),
+  canDelete: z.boolean(),
+  canEdit: z.boolean(),
+  categorySetting: z.any().optional(),
+  color: z.string(),
+  customFields: z.lazy(() => UpdateCategoryCustomFields$outboundSchema),
+  defaultListFilter: z.string(),
+  defaultSlowModeSeconds: z.nullable(z.string()),
+  defaultTopPeriod: z.string(),
+  defaultView: z.nullable(z.string()),
+  description: z.nullable(z.string()),
+  descriptionExcerpt: z.nullable(z.string()),
+  descriptionText: z.nullable(z.string()),
+  emailIn: z.nullable(z.string()),
+  emailInAllowStrangers: z.boolean(),
+  formTemplateIds: z.array(z.any()),
+  groupPermissions: z.array(
+    z.lazy(() => UpdateCategoryGroupPermissions$outboundSchema),
+  ),
+  hasChildren: z.nullable(z.boolean()),
+  id: z.number().int(),
+  mailinglistMirror: z.boolean(),
+  minimumRequiredTags: z.number().int(),
+  name: z.string(),
+  navigateToFirstPostAfterRead: z.boolean(),
+  notificationLevel: z.number().int(),
+  numFeaturedTopics: z.number().int(),
+  permission: z.nullable(z.number().int()),
+  position: z.number().int(),
+  postCount: z.number().int(),
+  readOnlyBanner: z.nullable(z.string()),
+  readRestricted: z.boolean(),
+  requiredTagGroups: z.array(
+    z.lazy(() => UpdateCategoryRequiredTagGroups$outboundSchema),
+  ),
+  searchPriority: z.number().int(),
+  showSubcategoryList: z.boolean(),
+  slug: z.string(),
+  sortAscending: z.nullable(z.string()),
+  sortOrder: z.nullable(z.string()),
+  subcategoryListStyle: z.string(),
+  textColor: z.string(),
+  topicCount: z.number().int(),
+  topicFeaturedLinkAllowed: z.boolean(),
+  topicTemplate: z.nullable(z.string()),
+  topicUrl: z.nullable(z.string()),
+  uploadedBackground: z.nullable(z.string()),
+  uploadedBackgroundDark: z.nullable(z.string()),
+  uploadedLogo: z.nullable(z.string()),
+  uploadedLogoDark: z.nullable(z.string()),
+}).transform((v) => {
+  return remap$(v, {
+    allTopicsWiki: "all_topics_wiki",
+    allowBadges: "allow_badges",
+    allowGlobalTags: "allow_global_tags",
+    allowUnlimitedOwnerEditsOnFirstPost:
+      "allow_unlimited_owner_edits_on_first_post",
+    allowedTagGroups: "allowed_tag_groups",
+    allowedTags: "allowed_tags",
+    autoCloseBasedOnLastPost: "auto_close_based_on_last_post",
+    autoCloseHours: "auto_close_hours",
+    availableGroups: "available_groups",
+    canDelete: "can_delete",
+    canEdit: "can_edit",
+    categorySetting: "category_setting",
+    customFields: "custom_fields",
+    defaultListFilter: "default_list_filter",
+    defaultSlowModeSeconds: "default_slow_mode_seconds",
+    defaultTopPeriod: "default_top_period",
+    defaultView: "default_view",
+    descriptionExcerpt: "description_excerpt",
+    descriptionText: "description_text",
+    emailIn: "email_in",
+    emailInAllowStrangers: "email_in_allow_strangers",
+    formTemplateIds: "form_template_ids",
+    groupPermissions: "group_permissions",
+    hasChildren: "has_children",
+    mailinglistMirror: "mailinglist_mirror",
+    minimumRequiredTags: "minimum_required_tags",
+    navigateToFirstPostAfterRead: "navigate_to_first_post_after_read",
+    notificationLevel: "notification_level",
+    numFeaturedTopics: "num_featured_topics",
+    postCount: "post_count",
+    readOnlyBanner: "read_only_banner",
+    readRestricted: "read_restricted",
+    requiredTagGroups: "required_tag_groups",
+    searchPriority: "search_priority",
+    showSubcategoryList: "show_subcategory_list",
+    sortAscending: "sort_ascending",
+    sortOrder: "sort_order",
+    subcategoryListStyle: "subcategory_list_style",
+    textColor: "text_color",
+    topicCount: "topic_count",
+    topicFeaturedLinkAllowed: "topic_featured_link_allowed",
+    topicTemplate: "topic_template",
+    topicUrl: "topic_url",
+    uploadedBackground: "uploaded_background",
+    uploadedBackgroundDark: "uploaded_background_dark",
+    uploadedLogo: "uploaded_logo",
+    uploadedLogoDark: "uploaded_logo_dark",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace UpdateCategoryCategory$ {
+  /** @deprecated use `UpdateCategoryCategory$inboundSchema` instead. */
+  export const inboundSchema = UpdateCategoryCategory$inboundSchema;
+  /** @deprecated use `UpdateCategoryCategory$outboundSchema` instead. */
+  export const outboundSchema = UpdateCategoryCategory$outboundSchema;
+  /** @deprecated use `UpdateCategoryCategory$Outbound` instead. */
+  export type Outbound = UpdateCategoryCategory$Outbound;
+}
+
+/** @internal */
+export const UpdateCategoryResponseBody$inboundSchema: z.ZodType<
+  UpdateCategoryResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  category: z.lazy(() => UpdateCategoryCategory$inboundSchema),
+  success: z.string(),
+});
+
+/** @internal */
+export type UpdateCategoryResponseBody$Outbound = {
+  category: UpdateCategoryCategory$Outbound;
+  success: string;
+};
+
+/** @internal */
+export const UpdateCategoryResponseBody$outboundSchema: z.ZodType<
+  UpdateCategoryResponseBody$Outbound,
+  z.ZodTypeDef,
+  UpdateCategoryResponseBody
+> = z.object({
+  category: z.lazy(() => UpdateCategoryCategory$outboundSchema),
+  success: 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 UpdateCategoryResponseBody$ {
+  /** @deprecated use `UpdateCategoryResponseBody$inboundSchema` instead. */
+  export const inboundSchema = UpdateCategoryResponseBody$inboundSchema;
+  /** @deprecated use `UpdateCategoryResponseBody$outboundSchema` instead. */
+  export const outboundSchema = UpdateCategoryResponseBody$outboundSchema;
+  /** @deprecated use `UpdateCategoryResponseBody$Outbound` instead. */
+  export type Outbound = UpdateCategoryResponseBody$Outbound;
+}