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

package/src/models/inputwizwebhook.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 InputWizWebhookType = {
-  WizWebhook: "wiz_webhook",
-} as const;
-export type InputWizWebhookType = ClosedEnum<typeof InputWizWebhookType>;
-
 export type InputWizWebhookConnection = {
   pipeline?: string | undefined;
   output: string;
@@ -186,7 +177,7 @@ export type InputWizWebhook = {
    * Unique ID for this input
    */
   id?: string | undefined;
-  type: InputWizWebhookType;
+  type: "wiz_webhook";
   disabled?: boolean | undefined;
   /**
    * Pipeline to process data from this Source before sending it through the Routes
@@ -297,15 +288,6 @@ export type InputWizWebhook = {
   description?: string | undefined;
 };
 
-/** @internal */
-export const InputWizWebhookType$inboundSchema: z.ZodNativeEnum<
-  typeof InputWizWebhookType
-> = z.nativeEnum(InputWizWebhookType);
-/** @internal */
-export const InputWizWebhookType$outboundSchema: z.ZodNativeEnum<
-  typeof InputWizWebhookType
-> = InputWizWebhookType$inboundSchema;
-
 /** @internal */
 export const InputWizWebhookConnection$inboundSchema: z.ZodType<
   InputWizWebhookConnection,
@@ -353,40 +335,26 @@ export const InputWizWebhookMode$inboundSchema: z.ZodType<
   InputWizWebhookMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWizWebhookMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWizWebhookMode);
 /** @internal */
 export const InputWizWebhookMode$outboundSchema: z.ZodType<
-  InputWizWebhookMode,
+  string,
   z.ZodTypeDef,
   InputWizWebhookMode
-> = z.union([
-  z.nativeEnum(InputWizWebhookMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWizWebhookMode);
 
 /** @internal */
 export const InputWizWebhookCompression$inboundSchema: z.ZodType<
   InputWizWebhookCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWizWebhookCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWizWebhookCompression);
 /** @internal */
 export const InputWizWebhookCompression$outboundSchema: z.ZodType<
-  InputWizWebhookCompression,
+  string,
   z.ZodTypeDef,
   InputWizWebhookCompression
-> = z.union([
-  z.nativeEnum(InputWizWebhookCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWizWebhookCompression);
 
 /** @internal */
 export const InputWizWebhookPqControls$inboundSchema: z.ZodType<
@@ -486,40 +454,26 @@ export const InputWizWebhookMinimumTLSVersion$inboundSchema: z.ZodType<
   InputWizWebhookMinimumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWizWebhookMinimumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWizWebhookMinimumTLSVersion);
 /** @internal */
 export const InputWizWebhookMinimumTLSVersion$outboundSchema: z.ZodType<
-  InputWizWebhookMinimumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputWizWebhookMinimumTLSVersion
-> = z.union([
-  z.nativeEnum(InputWizWebhookMinimumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWizWebhookMinimumTLSVersion);
 
 /** @internal */
 export const InputWizWebhookMaximumTLSVersion$inboundSchema: z.ZodType<
   InputWizWebhookMaximumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWizWebhookMaximumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWizWebhookMaximumTLSVersion);
 /** @internal */
 export const InputWizWebhookMaximumTLSVersion$outboundSchema: z.ZodType<
-  InputWizWebhookMaximumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputWizWebhookMaximumTLSVersion
-> = z.union([
-  z.nativeEnum(InputWizWebhookMaximumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWizWebhookMaximumTLSVersion);
 
 /** @internal */
 export const InputWizWebhookTLSSettingsServerSide$inboundSchema: z.ZodType<
@@ -738,7 +692,7 @@ export const InputWizWebhook$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: InputWizWebhookType$inboundSchema,
+  type: z.literal("wiz_webhook"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),
@@ -778,7 +732,7 @@ export const InputWizWebhook$inboundSchema: z.ZodType<
 /** @internal */
 export type InputWizWebhook$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "wiz_webhook";
   disabled: boolean;
   pipeline?: string | undefined;
   sendToRoutes: boolean;
@@ -818,7 +772,7 @@ export const InputWizWebhook$outboundSchema: z.ZodType<
   InputWizWebhook
 > = z.object({
   id: z.string().optional(),
-  type: InputWizWebhookType$outboundSchema,
+  type: z.literal("wiz_webhook"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),

package/src/models/inputzscalerhec.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 InputZscalerHecType = {
-  ZscalerHec: "zscaler_hec",
-} as const;
-export type InputZscalerHecType = ClosedEnum<typeof InputZscalerHecType>;
-
 export type InputZscalerHecConnection = {
   pipeline?: string | undefined;
   output: string;
@@ -213,7 +204,7 @@ export type InputZscalerHec = {
    * Unique ID for this input
    */
   id?: string | undefined;
-  type: InputZscalerHecType;
+  type: "zscaler_hec";
   disabled?: boolean | undefined;
   /**
    * Pipeline to process data from this Source before sending it through the Routes
@@ -325,15 +316,6 @@ export type InputZscalerHec = {
   description?: string | undefined;
 };
 
-/** @internal */
-export const InputZscalerHecType$inboundSchema: z.ZodNativeEnum<
-  typeof InputZscalerHecType
-> = z.nativeEnum(InputZscalerHecType);
-/** @internal */
-export const InputZscalerHecType$outboundSchema: z.ZodNativeEnum<
-  typeof InputZscalerHecType
-> = InputZscalerHecType$inboundSchema;
-
 /** @internal */
 export const InputZscalerHecConnection$inboundSchema: z.ZodType<
   InputZscalerHecConnection,
@@ -381,40 +363,26 @@ export const InputZscalerHecMode$inboundSchema: z.ZodType<
   InputZscalerHecMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputZscalerHecMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputZscalerHecMode);
 /** @internal */
 export const InputZscalerHecMode$outboundSchema: z.ZodType<
-  InputZscalerHecMode,
+  string,
   z.ZodTypeDef,
   InputZscalerHecMode
-> = z.union([
-  z.nativeEnum(InputZscalerHecMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputZscalerHecMode);
 
 /** @internal */
 export const InputZscalerHecCompression$inboundSchema: z.ZodType<
   InputZscalerHecCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputZscalerHecCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputZscalerHecCompression);
 /** @internal */
 export const InputZscalerHecCompression$outboundSchema: z.ZodType<
-  InputZscalerHecCompression,
+  string,
   z.ZodTypeDef,
   InputZscalerHecCompression
-> = z.union([
-  z.nativeEnum(InputZscalerHecCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputZscalerHecCompression);
 
 /** @internal */
 export const InputZscalerHecPqControls$inboundSchema: z.ZodType<
@@ -514,20 +482,13 @@ export const InputZscalerHecAuthenticationMethod$inboundSchema: z.ZodType<
   InputZscalerHecAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputZscalerHecAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputZscalerHecAuthenticationMethod);
 /** @internal */
 export const InputZscalerHecAuthenticationMethod$outboundSchema: z.ZodType<
-  InputZscalerHecAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   InputZscalerHecAuthenticationMethod
-> = z.union([
-  z.nativeEnum(InputZscalerHecAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputZscalerHecAuthenticationMethod);
 
 /** @internal */
 export const InputZscalerHecAuthTokenMetadatum$inboundSchema: z.ZodType<
@@ -641,40 +602,26 @@ export const InputZscalerHecMinimumTLSVersion$inboundSchema: z.ZodType<
   InputZscalerHecMinimumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputZscalerHecMinimumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputZscalerHecMinimumTLSVersion);
 /** @internal */
 export const InputZscalerHecMinimumTLSVersion$outboundSchema: z.ZodType<
-  InputZscalerHecMinimumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputZscalerHecMinimumTLSVersion
-> = z.union([
-  z.nativeEnum(InputZscalerHecMinimumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputZscalerHecMinimumTLSVersion);
 
 /** @internal */
 export const InputZscalerHecMaximumTLSVersion$inboundSchema: z.ZodType<
   InputZscalerHecMaximumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputZscalerHecMaximumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputZscalerHecMaximumTLSVersion);
 /** @internal */
 export const InputZscalerHecMaximumTLSVersion$outboundSchema: z.ZodType<
-  InputZscalerHecMaximumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputZscalerHecMaximumTLSVersion
-> = z.union([
-  z.nativeEnum(InputZscalerHecMaximumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputZscalerHecMaximumTLSVersion);
 
 /** @internal */
 export const InputZscalerHecTLSSettingsServerSide$inboundSchema: z.ZodType<
@@ -797,7 +744,7 @@ export const InputZscalerHec$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: InputZscalerHecType$inboundSchema,
+  type: z.literal("zscaler_hec"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),
@@ -837,7 +784,7 @@ export const InputZscalerHec$inboundSchema: z.ZodType<
 /** @internal */
 export type InputZscalerHec$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "zscaler_hec";
   disabled: boolean;
   pipeline?: string | undefined;
   sendToRoutes: boolean;
@@ -878,7 +825,7 @@ export const InputZscalerHec$outboundSchema: z.ZodType<
   InputZscalerHec
 > = z.object({
   id: z.string().optional(),
-  type: InputZscalerHecType$outboundSchema,
+  type: z.literal("zscaler_hec"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),

package/src/models/jobstatus.ts

@@ -4,7 +4,8 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../lib/schemas.js";
-import { catchUnrecognizedEnum, OpenEnum } 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";
 
@@ -37,11 +38,8 @@ export type JobStatus = {
 };
 
 /** @internal */
-export const State$inboundSchema: z.ZodType<State, z.ZodTypeDef, unknown> = z
-  .union([
-    z.nativeEnum(State),
-    z.number().transform(catchUnrecognizedEnum),
-  ]);
+export const State$inboundSchema: z.ZodType<State, z.ZodTypeDef, unknown> =
+  openEnums.inboundSchemaInt(State);
 
 /** @internal */
 export const JobStatus$inboundSchema: z.ZodType<

package/src/models/lakehouseconnectiontype.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 LakehouseConnectionType = {
   Cache: "cache",
@@ -20,17 +17,10 @@ export const LakehouseConnectionType$inboundSchema: z.ZodType<
   LakehouseConnectionType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(LakehouseConnectionType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(LakehouseConnectionType);
 /** @internal */
 export const LakehouseConnectionType$outboundSchema: z.ZodType<
-  LakehouseConnectionType,
+  string,
   z.ZodTypeDef,
   LakehouseConnectionType
-> = z.union([
-  z.nativeEnum(LakehouseConnectionType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(LakehouseConnectionType);

package/src/models/masterworkerentry.ts

@@ -4,7 +4,8 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../lib/schemas.js";
-import { catchUnrecognizedEnum, OpenEnum } 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";
 import {
@@ -38,7 +39,7 @@ export type MasterWorkerEntry = {
   group: string;
   id: string;
   info: NodeProvidedInfo;
-  lastMetrics?: { [k: string]: { [k: string]: any } } | undefined;
+  lastMetrics?: { [k: string]: any } | undefined;
   lastMsgTime: number;
   metadata?: HeartbeatMetadata | undefined;
   nodeUpgradeStatus?: NodeUpgradeStatus | undefined;
@@ -53,11 +54,7 @@ export const MasterWorkerEntryType$inboundSchema: z.ZodType<
   MasterWorkerEntryType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(MasterWorkerEntryType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(MasterWorkerEntryType);
 
 /** @internal */
 export const MasterWorkerEntryWorkers$inboundSchema: z.ZodType<
@@ -90,7 +87,7 @@ export const MasterWorkerEntry$inboundSchema: z.ZodType<
   group: z.string(),
   id: z.string(),
   info: NodeProvidedInfo$inboundSchema,
-  lastMetrics: z.record(z.record(z.any())).optional(),
+  lastMetrics: z.record(z.any()).optional(),
   lastMsgTime: z.number(),
   metadata: HeartbeatMetadata$inboundSchema.optional(),
   nodeUpgradeStatus: NodeUpgradeStatus$inboundSchema.optional(),

package/src/models/nodeactiveupgradestatus.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { catchUnrecognizedEnum, OpenEnum } from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 
 export const NodeActiveUpgradeStatus = {
   Zero: 0,
@@ -17,8 +18,4 @@ export const NodeActiveUpgradeStatus$inboundSchema: z.ZodType<
   NodeActiveUpgradeStatus,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(NodeActiveUpgradeStatus),
-    z.number().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchemaInt(NodeActiveUpgradeStatus);

package/src/models/nodefailedupgradestatus.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { catchUnrecognizedEnum, OpenEnum } from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 
 export const NodeFailedUpgradeStatus = {
   Zero: 0,
@@ -16,8 +17,4 @@ export const NodeFailedUpgradeStatus$inboundSchema: z.ZodType<
   NodeFailedUpgradeStatus,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(NodeFailedUpgradeStatus),
-    z.number().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchemaInt(NodeFailedUpgradeStatus);

package/src/models/nodeskippedupgradestatus.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { catchUnrecognizedEnum, OpenEnum } from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 
 export const NodeSkippedUpgradeStatus = {
   Zero: 0,
@@ -20,8 +21,4 @@ export const NodeSkippedUpgradeStatus$inboundSchema: z.ZodType<
   NodeSkippedUpgradeStatus,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(NodeSkippedUpgradeStatus),
-    z.number().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchemaInt(NodeSkippedUpgradeStatus);

package/src/models/nodeupgradestate.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { catchUnrecognizedEnum, OpenEnum } from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 
 export const NodeUpgradeState = {
   Zero: 0,
@@ -18,8 +19,4 @@ export const NodeUpgradeState$inboundSchema: z.ZodType<
   NodeUpgradeState,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(NodeUpgradeState),
-    z.number().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchemaInt(NodeUpgradeState);

package/src/models/operations/createauthlogin.ts

@@ -0,0 +1,40 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import * as models from "../index.js";
+
+export type CreateAuthLoginResponse = {
+  headers: { [k: string]: Array<string> };
+  result: models.AuthToken;
+};
+
+/** @internal */
+export const CreateAuthLoginResponse$inboundSchema: z.ZodType<
+  CreateAuthLoginResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  Headers: z.record(z.array(z.string())).default({}),
+  Result: models.AuthToken$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "Headers": "headers",
+    "Result": "result",
+  });
+});
+
+export function createAuthLoginResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateAuthLoginResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateAuthLoginResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateAuthLoginResponse' from JSON`,
+  );
+}

package/src/models/operations/createconfiggroupbyproduct.ts

@@ -8,7 +8,7 @@ import * as models from "../index.js";
 
 export type CreateConfigGroupByProductRequest = {
   /**
-   * required Name of the Cribl product to add the Worker Group or Edge Fleet to.
+   * Name of the Cribl product to add the Worker Group or Edge Fleet to.
    */
   product: models.ProductsCore;
   /**

package/src/models/operations/getcribllakedatasetbylakeid.ts

@@ -9,11 +9,41 @@ export type GetCriblLakeDatasetByLakeIdRequest = {
    * The <code>id</code> of the Lake that contains the Lake Datasets to list.
    */
   lakeId: string;
+  /**
+   * Filter datasets by storage location ID. Use <code>default</code> for default storage location.
+   */
+  storageLocationId?: string | undefined;
+  /**
+   * Filter datasets by format. Set to <code>ddss</code> to return only DDSS datasets.
+   */
+  format?: string | undefined;
+  /**
+   * Exclude DDSS format datasets from the response.
+   */
+  excludeDDSS?: boolean | undefined;
+  /**
+   * Exclude deleted datasets from the response.
+   */
+  excludeDeleted?: boolean | undefined;
+  /**
+   * Exclude internal datasets (those with IDs starting with <code>cribl_</code>) from the response.
+   */
+  excludeInternal?: boolean | undefined;
+  /**
+   * Exclude BYOS (Bring Your Own Storage) datasets from the response.
+   */
+  excludeBYOS?: boolean | undefined;
 };
 
 /** @internal */
 export type GetCriblLakeDatasetByLakeIdRequest$Outbound = {
   lakeId: string;
+  storageLocationId?: string | undefined;
+  format?: string | undefined;
+  excludeDDSS?: boolean | undefined;
+  excludeDeleted?: boolean | undefined;
+  excludeInternal?: boolean | undefined;
+  excludeBYOS?: boolean | undefined;
 };
 
 /** @internal */
@@ -23,6 +53,12 @@ export const GetCriblLakeDatasetByLakeIdRequest$outboundSchema: z.ZodType<
   GetCriblLakeDatasetByLakeIdRequest
 > = z.object({
   lakeId: z.string(),
+  storageLocationId: z.string().optional(),
+  format: z.string().optional(),
+  excludeDDSS: z.boolean().optional(),
+  excludeDeleted: z.boolean().optional(),
+  excludeInternal: z.boolean().optional(),
+  excludeBYOS: z.boolean().optional(),
 });
 
 export function getCriblLakeDatasetByLakeIdRequestToJSON(

package/src/models/operations/getversioncount.ts

@@ -3,7 +3,6 @@
  */
 
 import * as z from "zod/v3";
-import { remap as remap$ } from "../../lib/primitives.js";
 
 export type GetVersionCountRequest = {
   /**
@@ -13,13 +12,13 @@ export type GetVersionCountRequest = {
   /**
    * The Git commit hash to use as the starting point for the count.
    */
-  id?: string | undefined;
+  commit?: string | undefined;
 };
 
 /** @internal */
 export type GetVersionCountRequest$Outbound = {
   groupId?: string | undefined;
-  ID?: string | undefined;
+  commit?: string | undefined;
 };
 
 /** @internal */
@@ -29,11 +28,7 @@ export const GetVersionCountRequest$outboundSchema: z.ZodType<
   GetVersionCountRequest
 > = z.object({
   groupId: z.string().optional(),
-  id: z.string().optional(),
-}).transform((v) => {
-  return remap$(v, {
-    id: "ID",
-  });
+  commit: z.string().optional(),
 });
 
 export function getVersionCountRequestToJSON(