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

package/src/models/outputxsiam.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 OutputXsiamType = {
-  Xsiam: "xsiam",
-} as const;
-export type OutputXsiamType = ClosedEnum<typeof OutputXsiamType>;
-
 export type OutputXsiamExtraHttpHeader = {
   name?: string | undefined;
   value: string;
@@ -195,7 +186,7 @@ export type OutputXsiam = {
    * Unique ID for this output
    */
   id?: string | undefined;
-  type: OutputXsiamType;
+  type: "xsiam";
   /**
    * Pipeline to process data before sending out to this output
    */
@@ -354,15 +345,6 @@ export type OutputXsiam = {
   pqControls?: OutputXsiamPqControls | undefined;
 };
 
-/** @internal */
-export const OutputXsiamType$inboundSchema: z.ZodNativeEnum<
-  typeof OutputXsiamType
-> = z.nativeEnum(OutputXsiamType);
-/** @internal */
-export const OutputXsiamType$outboundSchema: z.ZodNativeEnum<
-  typeof OutputXsiamType
-> = OutputXsiamType$inboundSchema;
-
 /** @internal */
 export const OutputXsiamExtraHttpHeader$inboundSchema: z.ZodType<
   OutputXsiamExtraHttpHeader,
@@ -410,40 +392,26 @@ export const OutputXsiamFailedRequestLoggingMode$inboundSchema: z.ZodType<
   OutputXsiamFailedRequestLoggingMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputXsiamFailedRequestLoggingMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputXsiamFailedRequestLoggingMode);
 /** @internal */
 export const OutputXsiamFailedRequestLoggingMode$outboundSchema: z.ZodType<
-  OutputXsiamFailedRequestLoggingMode,
+  string,
   z.ZodTypeDef,
   OutputXsiamFailedRequestLoggingMode
-> = z.union([
-  z.nativeEnum(OutputXsiamFailedRequestLoggingMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputXsiamFailedRequestLoggingMode);
 
 /** @internal */
 export const OutputXsiamAuthenticationMethod$inboundSchema: z.ZodType<
   OutputXsiamAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputXsiamAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputXsiamAuthenticationMethod);
 /** @internal */
 export const OutputXsiamAuthenticationMethod$outboundSchema: z.ZodType<
-  OutputXsiamAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   OutputXsiamAuthenticationMethod
-> = z.union([
-  z.nativeEnum(OutputXsiamAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputXsiamAuthenticationMethod);
 
 /** @internal */
 export const OutputXsiamResponseRetrySetting$inboundSchema: z.ZodType<
@@ -550,20 +518,13 @@ export const OutputXsiamBackpressureBehavior$inboundSchema: z.ZodType<
   OutputXsiamBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputXsiamBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputXsiamBackpressureBehavior);
 /** @internal */
 export const OutputXsiamBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputXsiamBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputXsiamBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputXsiamBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputXsiamBackpressureBehavior);
 
 /** @internal */
 export const OutputXsiamUrl$inboundSchema: z.ZodType<
@@ -608,60 +569,39 @@ export const OutputXsiamMode$inboundSchema: z.ZodType<
   OutputXsiamMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputXsiamMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputXsiamMode);
 /** @internal */
 export const OutputXsiamMode$outboundSchema: z.ZodType<
-  OutputXsiamMode,
+  string,
   z.ZodTypeDef,
   OutputXsiamMode
-> = z.union([
-  z.nativeEnum(OutputXsiamMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputXsiamMode);
 
 /** @internal */
 export const OutputXsiamCompression$inboundSchema: z.ZodType<
   OutputXsiamCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputXsiamCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputXsiamCompression);
 /** @internal */
 export const OutputXsiamCompression$outboundSchema: z.ZodType<
-  OutputXsiamCompression,
+  string,
   z.ZodTypeDef,
   OutputXsiamCompression
-> = z.union([
-  z.nativeEnum(OutputXsiamCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputXsiamCompression);
 
 /** @internal */
 export const OutputXsiamQueueFullBehavior$inboundSchema: z.ZodType<
   OutputXsiamQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputXsiamQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputXsiamQueueFullBehavior);
 /** @internal */
 export const OutputXsiamQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputXsiamQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputXsiamQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputXsiamQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputXsiamQueueFullBehavior);
 
 /** @internal */
 export const OutputXsiamPqControls$inboundSchema: z.ZodType<
@@ -703,7 +643,7 @@ export const OutputXsiam$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: OutputXsiamType$inboundSchema,
+  type: z.literal("xsiam"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),
@@ -758,7 +698,7 @@ export const OutputXsiam$inboundSchema: z.ZodType<
 /** @internal */
 export type OutputXsiam$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "xsiam";
   pipeline?: string | undefined;
   systemFields?: Array<string> | undefined;
   environment?: string | undefined;
@@ -811,7 +751,7 @@ export const OutputXsiam$outboundSchema: z.ZodType<
   OutputXsiam
 > = z.object({
   id: z.string().optional(),
-  type: OutputXsiamType$outboundSchema,
+  type: z.literal("xsiam"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),

package/src/models/piisettingsunion.ts

@@ -0,0 +1,121 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export type PiiSettings2 = {};
+
+export type PiiSettings1 = {
+  enablePiiDetection: boolean;
+};
+
+export type PiiSettingsUnion = PiiSettings1 | PiiSettings2;
+
+/** @internal */
+export const PiiSettings2$inboundSchema: z.ZodType<
+  PiiSettings2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+/** @internal */
+export type PiiSettings2$Outbound = {};
+
+/** @internal */
+export const PiiSettings2$outboundSchema: z.ZodType<
+  PiiSettings2$Outbound,
+  z.ZodTypeDef,
+  PiiSettings2
+> = z.object({});
+
+export function piiSettings2ToJSON(piiSettings2: PiiSettings2): string {
+  return JSON.stringify(PiiSettings2$outboundSchema.parse(piiSettings2));
+}
+export function piiSettings2FromJSON(
+  jsonString: string,
+): SafeParseResult<PiiSettings2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PiiSettings2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PiiSettings2' from JSON`,
+  );
+}
+
+/** @internal */
+export const PiiSettings1$inboundSchema: z.ZodType<
+  PiiSettings1,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  enablePiiDetection: z.boolean(),
+});
+/** @internal */
+export type PiiSettings1$Outbound = {
+  enablePiiDetection: boolean;
+};
+
+/** @internal */
+export const PiiSettings1$outboundSchema: z.ZodType<
+  PiiSettings1$Outbound,
+  z.ZodTypeDef,
+  PiiSettings1
+> = z.object({
+  enablePiiDetection: z.boolean(),
+});
+
+export function piiSettings1ToJSON(piiSettings1: PiiSettings1): string {
+  return JSON.stringify(PiiSettings1$outboundSchema.parse(piiSettings1));
+}
+export function piiSettings1FromJSON(
+  jsonString: string,
+): SafeParseResult<PiiSettings1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PiiSettings1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PiiSettings1' from JSON`,
+  );
+}
+
+/** @internal */
+export const PiiSettingsUnion$inboundSchema: z.ZodType<
+  PiiSettingsUnion,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => PiiSettings1$inboundSchema),
+  z.lazy(() => PiiSettings2$inboundSchema),
+]);
+/** @internal */
+export type PiiSettingsUnion$Outbound =
+  | PiiSettings1$Outbound
+  | PiiSettings2$Outbound;
+
+/** @internal */
+export const PiiSettingsUnion$outboundSchema: z.ZodType<
+  PiiSettingsUnion$Outbound,
+  z.ZodTypeDef,
+  PiiSettingsUnion
+> = z.union([
+  z.lazy(() => PiiSettings1$outboundSchema),
+  z.lazy(() => PiiSettings2$outboundSchema),
+]);
+
+export function piiSettingsUnionToJSON(
+  piiSettingsUnion: PiiSettingsUnion,
+): string {
+  return JSON.stringify(
+    PiiSettingsUnion$outboundSchema.parse(piiSettingsUnion),
+  );
+}
+export function piiSettingsUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<PiiSettingsUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PiiSettingsUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PiiSettingsUnion' from JSON`,
+  );
+}

package/src/models/productscore.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { OpenEnum, Unrecognized } from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 
 export const ProductsCore = {
   Stream: "stream",
@@ -13,10 +14,7 @@ export type ProductsCore = OpenEnum<typeof ProductsCore>;
 
 /** @internal */
 export const ProductsCore$outboundSchema: z.ZodType<
-  ProductsCore,
+  string,
   z.ZodTypeDef,
   ProductsCore
-> = z.union([
-  z.nativeEnum(ProductsCore),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(ProductsCore);

package/src/models/rbacresource.ts

@@ -3,11 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import {
-  catchUnrecognizedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 
 export const RbacResource = {
   Groups: "groups",
@@ -25,17 +22,10 @@ export const RbacResource$inboundSchema: z.ZodType<
   RbacResource,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(RbacResource),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(RbacResource);
 /** @internal */
 export const RbacResource$outboundSchema: z.ZodType<
-  RbacResource,
+  string,
   z.ZodTypeDef,
   RbacResource
-> = z.union([
-  z.nativeEnum(RbacResource),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(RbacResource);

package/src/models/rollbacksettingsunion.ts

@@ -0,0 +1,137 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export type RollbackSettings2 = {};
+
+export type RollbackSettings1 = {
+  rollbackEnabled: boolean;
+  rollbackRetries?: number | undefined;
+  rollbackTimeout?: number | undefined;
+};
+
+export type RollbackSettingsUnion = RollbackSettings1 | RollbackSettings2;
+
+/** @internal */
+export const RollbackSettings2$inboundSchema: z.ZodType<
+  RollbackSettings2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+/** @internal */
+export type RollbackSettings2$Outbound = {};
+
+/** @internal */
+export const RollbackSettings2$outboundSchema: z.ZodType<
+  RollbackSettings2$Outbound,
+  z.ZodTypeDef,
+  RollbackSettings2
+> = z.object({});
+
+export function rollbackSettings2ToJSON(
+  rollbackSettings2: RollbackSettings2,
+): string {
+  return JSON.stringify(
+    RollbackSettings2$outboundSchema.parse(rollbackSettings2),
+  );
+}
+export function rollbackSettings2FromJSON(
+  jsonString: string,
+): SafeParseResult<RollbackSettings2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RollbackSettings2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RollbackSettings2' from JSON`,
+  );
+}
+
+/** @internal */
+export const RollbackSettings1$inboundSchema: z.ZodType<
+  RollbackSettings1,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  rollbackEnabled: z.boolean(),
+  rollbackRetries: z.number().optional(),
+  rollbackTimeout: z.number().optional(),
+});
+/** @internal */
+export type RollbackSettings1$Outbound = {
+  rollbackEnabled: boolean;
+  rollbackRetries?: number | undefined;
+  rollbackTimeout?: number | undefined;
+};
+
+/** @internal */
+export const RollbackSettings1$outboundSchema: z.ZodType<
+  RollbackSettings1$Outbound,
+  z.ZodTypeDef,
+  RollbackSettings1
+> = z.object({
+  rollbackEnabled: z.boolean(),
+  rollbackRetries: z.number().optional(),
+  rollbackTimeout: z.number().optional(),
+});
+
+export function rollbackSettings1ToJSON(
+  rollbackSettings1: RollbackSettings1,
+): string {
+  return JSON.stringify(
+    RollbackSettings1$outboundSchema.parse(rollbackSettings1),
+  );
+}
+export function rollbackSettings1FromJSON(
+  jsonString: string,
+): SafeParseResult<RollbackSettings1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RollbackSettings1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RollbackSettings1' from JSON`,
+  );
+}
+
+/** @internal */
+export const RollbackSettingsUnion$inboundSchema: z.ZodType<
+  RollbackSettingsUnion,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => RollbackSettings1$inboundSchema),
+  z.lazy(() => RollbackSettings2$inboundSchema),
+]);
+/** @internal */
+export type RollbackSettingsUnion$Outbound =
+  | RollbackSettings1$Outbound
+  | RollbackSettings2$Outbound;
+
+/** @internal */
+export const RollbackSettingsUnion$outboundSchema: z.ZodType<
+  RollbackSettingsUnion$Outbound,
+  z.ZodTypeDef,
+  RollbackSettingsUnion
+> = z.union([
+  z.lazy(() => RollbackSettings1$outboundSchema),
+  z.lazy(() => RollbackSettings2$outboundSchema),
+]);
+
+export function rollbackSettingsUnionToJSON(
+  rollbackSettingsUnion: RollbackSettingsUnion,
+): string {
+  return JSON.stringify(
+    RollbackSettingsUnion$outboundSchema.parse(rollbackSettingsUnion),
+  );
+}
+export function rollbackSettingsUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<RollbackSettingsUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RollbackSettingsUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RollbackSettingsUnion' from JSON`,
+  );
+}