cribl-control-plane 0.4.0-beta.2 → 0.4.0-beta.20

package/src/models/inputjournalfiles.ts

@@ -4,20 +4,11 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../lib/schemas.js";
-import {
-  catchUnrecognizedEnum,
-  ClosedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
-export const InputJournalFilesType = {
-  JournalFiles: "journal_files",
-} as const;
-export type InputJournalFilesType = ClosedEnum<typeof InputJournalFilesType>;
-
 export type InputJournalFilesConnection = {
   pipeline?: string | undefined;
   output: string;
@@ -119,7 +110,7 @@ export type InputJournalFiles = {
    * Unique ID for this input
    */
   id?: string | undefined;
-  type: InputJournalFilesType;
+  type: "journal_files";
   disabled?: boolean | undefined;
   /**
    * Pipeline to process data from this Source before sending it through the Routes
@@ -177,15 +168,6 @@ export type InputJournalFiles = {
   description?: string | undefined;
 };
 
-/** @internal */
-export const InputJournalFilesType$inboundSchema: z.ZodNativeEnum<
-  typeof InputJournalFilesType
-> = z.nativeEnum(InputJournalFilesType);
-/** @internal */
-export const InputJournalFilesType$outboundSchema: z.ZodNativeEnum<
-  typeof InputJournalFilesType
-> = InputJournalFilesType$inboundSchema;
-
 /** @internal */
 export const InputJournalFilesConnection$inboundSchema: z.ZodType<
   InputJournalFilesConnection,
@@ -235,40 +217,26 @@ export const InputJournalFilesMode$inboundSchema: z.ZodType<
   InputJournalFilesMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputJournalFilesMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputJournalFilesMode);
 /** @internal */
 export const InputJournalFilesMode$outboundSchema: z.ZodType<
-  InputJournalFilesMode,
+  string,
   z.ZodTypeDef,
   InputJournalFilesMode
-> = z.union([
-  z.nativeEnum(InputJournalFilesMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputJournalFilesMode);
 
 /** @internal */
 export const InputJournalFilesCompression$inboundSchema: z.ZodType<
   InputJournalFilesCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputJournalFilesCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputJournalFilesCompression);
 /** @internal */
 export const InputJournalFilesCompression$outboundSchema: z.ZodType<
-  InputJournalFilesCompression,
+  string,
   z.ZodTypeDef,
   InputJournalFilesCompression
-> = z.union([
-  z.nativeEnum(InputJournalFilesCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputJournalFilesCompression);
 
 /** @internal */
 export const InputJournalFilesPqControls$inboundSchema: z.ZodType<
@@ -458,7 +426,7 @@ export const InputJournalFiles$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: InputJournalFilesType$inboundSchema,
+  type: z.literal("journal_files"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),
@@ -481,7 +449,7 @@ export const InputJournalFiles$inboundSchema: z.ZodType<
 /** @internal */
 export type InputJournalFiles$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "journal_files";
   disabled: boolean;
   pipeline?: string | undefined;
   sendToRoutes: boolean;
@@ -507,7 +475,7 @@ export const InputJournalFiles$outboundSchema: z.ZodType<
   InputJournalFiles
 > = z.object({
   id: z.string().optional(),
-  type: InputJournalFilesType$outboundSchema,
+  type: z.literal("journal_files"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),

package/src/models/inputkafka.ts

@@ -4,20 +4,11 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../lib/schemas.js";
-import {
-  catchUnrecognizedEnum,
-  ClosedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
-export const InputKafkaType = {
-  Kafka: "kafka",
-} as const;
-export type InputKafkaType = ClosedEnum<typeof InputKafkaType>;
-
 export type InputKafkaConnection = {
   pipeline?: string | undefined;
   output: string;
@@ -355,7 +346,7 @@ export type InputKafka = {
    * Unique ID for this input
    */
   id?: string | undefined;
-  type: InputKafkaType;
+  type: "kafka";
   disabled?: boolean | undefined;
   /**
    * Pipeline to process data from this Source before sending it through the Routes
@@ -437,9 +428,8 @@ export type InputKafka = {
   sasl?: InputKafkaAuthentication | undefined;
   tls?: InputKafkaTLSSettingsClientSide | undefined;
   /**
-   *       Timeout used to detect client failures when using Kafka's group-management facilities.
-   *
    * @remarks
+   *       Timeout used to detect client failures when using Kafka's group-management facilities.
    *       If the client sends no heartbeats to the broker before the timeout expires,
    *       the broker will remove the client from the group and initiate a rebalance.
    *       Value must be between the broker's configured group.min.session.timeout.ms and group.max.session.timeout.ms.
@@ -489,15 +479,6 @@ export type InputKafka = {
   description?: string | undefined;
 };
 
-/** @internal */
-export const InputKafkaType$inboundSchema: z.ZodNativeEnum<
-  typeof InputKafkaType
-> = z.nativeEnum(InputKafkaType);
-/** @internal */
-export const InputKafkaType$outboundSchema: z.ZodNativeEnum<
-  typeof InputKafkaType
-> = InputKafkaType$inboundSchema;
-
 /** @internal */
 export const InputKafkaConnection$inboundSchema: z.ZodType<
   InputKafkaConnection,
@@ -545,40 +526,26 @@ export const InputKafkaMode$inboundSchema: z.ZodType<
   InputKafkaMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKafkaMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKafkaMode);
 /** @internal */
 export const InputKafkaMode$outboundSchema: z.ZodType<
-  InputKafkaMode,
+  string,
   z.ZodTypeDef,
   InputKafkaMode
-> = z.union([
-  z.nativeEnum(InputKafkaMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKafkaMode);
 
 /** @internal */
 export const InputKafkaCompression$inboundSchema: z.ZodType<
   InputKafkaCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKafkaCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKafkaCompression);
 /** @internal */
 export const InputKafkaCompression$outboundSchema: z.ZodType<
-  InputKafkaCompression,
+  string,
   z.ZodTypeDef,
   InputKafkaCompression
-> = z.union([
-  z.nativeEnum(InputKafkaCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKafkaCompression);
 
 /** @internal */
 export const InputKafkaPqControls$inboundSchema: z.ZodType<
@@ -713,21 +680,14 @@ export const InputKafkaKafkaSchemaRegistryMinimumTLSVersion$inboundSchema:
     InputKafkaKafkaSchemaRegistryMinimumTLSVersion,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(InputKafkaKafkaSchemaRegistryMinimumTLSVersion),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(InputKafkaKafkaSchemaRegistryMinimumTLSVersion);
 /** @internal */
 export const InputKafkaKafkaSchemaRegistryMinimumTLSVersion$outboundSchema:
   z.ZodType<
-    InputKafkaKafkaSchemaRegistryMinimumTLSVersion,
+    string,
     z.ZodTypeDef,
     InputKafkaKafkaSchemaRegistryMinimumTLSVersion
-  > = z.union([
-    z.nativeEnum(InputKafkaKafkaSchemaRegistryMinimumTLSVersion),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  > = openEnums.outboundSchema(InputKafkaKafkaSchemaRegistryMinimumTLSVersion);
 
 /** @internal */
 export const InputKafkaKafkaSchemaRegistryMaximumTLSVersion$inboundSchema:
@@ -735,21 +695,14 @@ export const InputKafkaKafkaSchemaRegistryMaximumTLSVersion$inboundSchema:
     InputKafkaKafkaSchemaRegistryMaximumTLSVersion,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(InputKafkaKafkaSchemaRegistryMaximumTLSVersion),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(InputKafkaKafkaSchemaRegistryMaximumTLSVersion);
 /** @internal */
 export const InputKafkaKafkaSchemaRegistryMaximumTLSVersion$outboundSchema:
   z.ZodType<
-    InputKafkaKafkaSchemaRegistryMaximumTLSVersion,
+    string,
     z.ZodTypeDef,
     InputKafkaKafkaSchemaRegistryMaximumTLSVersion
-  > = z.union([
-    z.nativeEnum(InputKafkaKafkaSchemaRegistryMaximumTLSVersion),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  > = openEnums.outboundSchema(InputKafkaKafkaSchemaRegistryMaximumTLSVersion);
 
 /** @internal */
 export const InputKafkaKafkaSchemaRegistryTLSSettingsClientSide$inboundSchema:
@@ -909,40 +862,26 @@ export const InputKafkaAuthenticationMethod$inboundSchema: z.ZodType<
   InputKafkaAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKafkaAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKafkaAuthenticationMethod);
 /** @internal */
 export const InputKafkaAuthenticationMethod$outboundSchema: z.ZodType<
-  InputKafkaAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   InputKafkaAuthenticationMethod
-> = z.union([
-  z.nativeEnum(InputKafkaAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKafkaAuthenticationMethod);
 
 /** @internal */
 export const InputKafkaSASLMechanism$inboundSchema: z.ZodType<
   InputKafkaSASLMechanism,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKafkaSASLMechanism),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKafkaSASLMechanism);
 /** @internal */
 export const InputKafkaSASLMechanism$outboundSchema: z.ZodType<
-  InputKafkaSASLMechanism,
+  string,
   z.ZodTypeDef,
   InputKafkaSASLMechanism
-> = z.union([
-  z.nativeEnum(InputKafkaSASLMechanism),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKafkaSASLMechanism);
 
 /** @internal */
 export const InputKafkaOauthParam$inboundSchema: z.ZodType<
@@ -1121,40 +1060,26 @@ export const InputKafkaMinimumTLSVersion$inboundSchema: z.ZodType<
   InputKafkaMinimumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKafkaMinimumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKafkaMinimumTLSVersion);
 /** @internal */
 export const InputKafkaMinimumTLSVersion$outboundSchema: z.ZodType<
-  InputKafkaMinimumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputKafkaMinimumTLSVersion
-> = z.union([
-  z.nativeEnum(InputKafkaMinimumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKafkaMinimumTLSVersion);
 
 /** @internal */
 export const InputKafkaMaximumTLSVersion$inboundSchema: z.ZodType<
   InputKafkaMaximumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKafkaMaximumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKafkaMaximumTLSVersion);
 /** @internal */
 export const InputKafkaMaximumTLSVersion$outboundSchema: z.ZodType<
-  InputKafkaMaximumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputKafkaMaximumTLSVersion
-> = z.union([
-  z.nativeEnum(InputKafkaMaximumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKafkaMaximumTLSVersion);
 
 /** @internal */
 export const InputKafkaTLSSettingsClientSide$inboundSchema: z.ZodType<
@@ -1273,7 +1198,7 @@ export const InputKafka$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: InputKafkaType$inboundSchema,
+  type: z.literal("kafka"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),
@@ -1314,7 +1239,7 @@ export const InputKafka$inboundSchema: z.ZodType<
 /** @internal */
 export type InputKafka$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "kafka";
   disabled: boolean;
   pipeline?: string | undefined;
   sendToRoutes: boolean;
@@ -1359,7 +1284,7 @@ export const InputKafka$outboundSchema: z.ZodType<
   InputKafka
 > = z.object({
   id: z.string().optional(),
-  type: InputKafkaType$outboundSchema,
+  type: z.literal("kafka"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),

package/src/models/inputkinesis.ts

@@ -4,20 +4,11 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../lib/schemas.js";
-import {
-  catchUnrecognizedEnum,
-  ClosedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
-export const InputKinesisType = {
-  Kinesis: "kinesis",
-} as const;
-export type InputKinesisType = ClosedEnum<typeof InputKinesisType>;
-
 export type InputKinesisConnection = {
   pipeline?: string | undefined;
   output: string;
@@ -208,7 +199,7 @@ export type InputKinesis = {
    * Unique ID for this input
    */
   id?: string | undefined;
-  type: InputKinesisType;
+  type: "kinesis";
   disabled?: boolean | undefined;
   /**
    * Pipeline to process data from this Source before sending it through the Routes
@@ -328,15 +319,6 @@ export type InputKinesis = {
   awsSecret?: string | undefined;
 };
 
-/** @internal */
-export const InputKinesisType$inboundSchema: z.ZodNativeEnum<
-  typeof InputKinesisType
-> = z.nativeEnum(InputKinesisType);
-/** @internal */
-export const InputKinesisType$outboundSchema: z.ZodNativeEnum<
-  typeof InputKinesisType
-> = InputKinesisType$inboundSchema;
-
 /** @internal */
 export const InputKinesisConnection$inboundSchema: z.ZodType<
   InputKinesisConnection,
@@ -384,40 +366,26 @@ export const InputKinesisMode$inboundSchema: z.ZodType<
   InputKinesisMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKinesisMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKinesisMode);
 /** @internal */
 export const InputKinesisMode$outboundSchema: z.ZodType<
-  InputKinesisMode,
+  string,
   z.ZodTypeDef,
   InputKinesisMode
-> = z.union([
-  z.nativeEnum(InputKinesisMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKinesisMode);
 
 /** @internal */
 export const InputKinesisCompression$inboundSchema: z.ZodType<
   InputKinesisCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKinesisCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKinesisCompression);
 /** @internal */
 export const InputKinesisCompression$outboundSchema: z.ZodType<
-  InputKinesisCompression,
+  string,
   z.ZodTypeDef,
   InputKinesisCompression
-> = z.union([
-  z.nativeEnum(InputKinesisCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKinesisCompression);
 
 /** @internal */
 export const InputKinesisPqControls$inboundSchema: z.ZodType<
@@ -513,100 +481,65 @@ export const ShardIteratorStart$inboundSchema: z.ZodType<
   ShardIteratorStart,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ShardIteratorStart),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ShardIteratorStart);
 /** @internal */
 export const ShardIteratorStart$outboundSchema: z.ZodType<
-  ShardIteratorStart,
+  string,
   z.ZodTypeDef,
   ShardIteratorStart
-> = z.union([
-  z.nativeEnum(ShardIteratorStart),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(ShardIteratorStart);
 
 /** @internal */
 export const InputKinesisRecordDataFormat$inboundSchema: z.ZodType<
   InputKinesisRecordDataFormat,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKinesisRecordDataFormat),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKinesisRecordDataFormat);
 /** @internal */
 export const InputKinesisRecordDataFormat$outboundSchema: z.ZodType<
-  InputKinesisRecordDataFormat,
+  string,
   z.ZodTypeDef,
   InputKinesisRecordDataFormat
-> = z.union([
-  z.nativeEnum(InputKinesisRecordDataFormat),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKinesisRecordDataFormat);
 
 /** @internal */
 export const ShardLoadBalancing$inboundSchema: z.ZodType<
   ShardLoadBalancing,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ShardLoadBalancing),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ShardLoadBalancing);
 /** @internal */
 export const ShardLoadBalancing$outboundSchema: z.ZodType<
-  ShardLoadBalancing,
+  string,
   z.ZodTypeDef,
   ShardLoadBalancing
-> = z.union([
-  z.nativeEnum(ShardLoadBalancing),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(ShardLoadBalancing);
 
 /** @internal */
 export const InputKinesisAuthenticationMethod$inboundSchema: z.ZodType<
   InputKinesisAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKinesisAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKinesisAuthenticationMethod);
 /** @internal */
 export const InputKinesisAuthenticationMethod$outboundSchema: z.ZodType<
-  InputKinesisAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   InputKinesisAuthenticationMethod
-> = z.union([
-  z.nativeEnum(InputKinesisAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKinesisAuthenticationMethod);
 
 /** @internal */
 export const InputKinesisSignatureVersion$inboundSchema: z.ZodType<
   InputKinesisSignatureVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKinesisSignatureVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKinesisSignatureVersion);
 /** @internal */
 export const InputKinesisSignatureVersion$outboundSchema: z.ZodType<
-  InputKinesisSignatureVersion,
+  string,
   z.ZodTypeDef,
   InputKinesisSignatureVersion
-> = z.union([
-  z.nativeEnum(InputKinesisSignatureVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKinesisSignatureVersion);
 
 /** @internal */
 export const InputKinesisMetadatum$inboundSchema: z.ZodType<
@@ -657,7 +590,7 @@ export const InputKinesis$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: InputKinesisType$inboundSchema,
+  type: z.literal("kinesis"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),
@@ -700,7 +633,7 @@ export const InputKinesis$inboundSchema: z.ZodType<
 /** @internal */
 export type InputKinesis$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "kinesis";
   disabled: boolean;
   pipeline?: string | undefined;
   sendToRoutes: boolean;
@@ -743,7 +676,7 @@ export const InputKinesis$outboundSchema: z.ZodType<
   InputKinesis
 > = z.object({
   id: z.string().optional(),
-  type: InputKinesisType$outboundSchema,
+  type: z.literal("kinesis"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),