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

package/src/models/heartbeatmetadata.ts

@@ -7,13 +7,11 @@ import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
-export type HeartbeatMetadataTags = {};
-
 export type HeartbeatMetadataAws = {
   enabled: boolean;
   instanceId: string;
   region: string;
-  tags?: HeartbeatMetadataTags | undefined;
+  tags?: { [k: string]: string } | undefined;
   type: string;
   zone: string;
 };
@@ -53,23 +51,6 @@ export type HeartbeatMetadata = {
   os?: HeartbeatMetadataOs | undefined;
 };
 
-/** @internal */
-export const HeartbeatMetadataTags$inboundSchema: z.ZodType<
-  HeartbeatMetadataTags,
-  z.ZodTypeDef,
-  unknown
-> = z.object({});
-
-export function heartbeatMetadataTagsFromJSON(
-  jsonString: string,
-): SafeParseResult<HeartbeatMetadataTags, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => HeartbeatMetadataTags$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'HeartbeatMetadataTags' from JSON`,
-  );
-}
-
 /** @internal */
 export const HeartbeatMetadataAws$inboundSchema: z.ZodType<
   HeartbeatMetadataAws,
@@ -79,7 +60,7 @@ export const HeartbeatMetadataAws$inboundSchema: z.ZodType<
   enabled: z.boolean(),
   instanceId: z.string(),
   region: z.string(),
-  tags: z.lazy(() => HeartbeatMetadataTags$inboundSchema).optional(),
+  tags: z.record(z.string()).optional(),
   type: z.string(),
   zone: z.string(),
 });

package/src/models/index.ts

@@ -12,6 +12,35 @@ export * from "./commit.js";
 export * from "./configgroup.js";
 export * from "./configgroupcloud.js";
 export * from "./configgrouplookups.js";
+export * from "./countedbranchinfo.js";
+export * from "./countedconfiggroup.js";
+export * from "./countedcribllakedataset.js";
+export * from "./counteddistributedsummary.js";
+export * from "./countedgitcommitsummary.js";
+export * from "./countedgitcountresult.js";
+export * from "./countedgitdiffresult.js";
+export * from "./countedgitfilesresponse.js";
+export * from "./countedgitinfo.js";
+export * from "./countedgitlogresult.js";
+export * from "./countedgitrevertresult.js";
+export * from "./countedgitshowresult.js";
+export * from "./countedgitstatusresult.js";
+export * from "./countedinput.js";
+export * from "./countedinputsplunkhec.js";
+export * from "./countedjobinfo.js";
+export * from "./countedmasterworkerentry.js";
+export * from "./countednumber.js";
+export * from "./countedobject.js";
+export * from "./countedoutput.js";
+export * from "./countedoutputsamplesresponse.js";
+export * from "./countedoutputtestresponse.js";
+export * from "./countedpackinfo.js";
+export * from "./countedpackinstallinfo.js";
+export * from "./countedpipeline.js";
+export * from "./countedroutes.js";
+export * from "./countedstring.js";
+export * from "./countedteamaccesscontrollist.js";
+export * from "./counteduseraccesscontrollist.js";
 export * from "./criblevent.js";
 export * from "./cribllakedataset.js";
 export * from "./cribllakedatasetupdate.js";
@@ -106,7 +135,6 @@ export * from "./lakedatasetmetrics.js";
 export * from "./lakedatasetsearchconfig.js";
 export * from "./lakehouseconnectiontype.js";
 export * from "./logininfo.js";
-export * from "./lookupversions.js";
 export * from "./masterworkerentry.js";
 export * from "./nodeactiveupgradestatus.js";
 export * from "./nodefailedupgradestatus.js";

package/src/models/inputcloudflarehec.ts

@@ -100,6 +100,7 @@ export type InputCloudflareHecPq = {
  */
 export const InputCloudflareHecAuthenticationMethod = {
   Secret: "secret",
+  Manual: "manual",
 } as const;
 /**
  * Select Secret to use a text secret to authenticate
@@ -121,8 +122,14 @@ export type InputCloudflareHecAuthToken = {
    * Select Secret to use a text secret to authenticate
    */
   authType?: InputCloudflareHecAuthenticationMethod | undefined;
-  tokenSecret?: any | undefined;
-  token?: any | undefined;
+  /**
+   * Select or create a stored text secret
+   */
+  tokenSecret?: string | undefined;
+  /**
+   * Shared secret to be provided by any client (Authorization: <token>)
+   */
+  token?: string | undefined;
   enabled?: boolean | undefined;
   description?: string | undefined;
   /**
@@ -586,8 +593,8 @@ export const InputCloudflareHecAuthToken$inboundSchema: z.ZodType<
   authType: InputCloudflareHecAuthenticationMethod$inboundSchema.default(
     "secret",
   ),
-  tokenSecret: z.any().optional(),
-  token: z.any().optional(),
+  tokenSecret: z.string().optional(),
+  token: z.string().optional(),
   enabled: z.boolean().default(true),
   description: z.string().optional(),
   allowedIndexesAtToken: z.array(z.string()).optional(),
@@ -598,8 +605,8 @@ export const InputCloudflareHecAuthToken$inboundSchema: z.ZodType<
 /** @internal */
 export type InputCloudflareHecAuthToken$Outbound = {
   authType: string;
-  tokenSecret?: any | undefined;
-  token?: any | undefined;
+  tokenSecret?: string | undefined;
+  token?: string | undefined;
   enabled: boolean;
   description?: string | undefined;
   allowedIndexesAtToken?: Array<string> | undefined;
@@ -615,8 +622,8 @@ export const InputCloudflareHecAuthToken$outboundSchema: z.ZodType<
   authType: InputCloudflareHecAuthenticationMethod$outboundSchema.default(
     "secret",
   ),
-  tokenSecret: z.any().optional(),
-  token: z.any().optional(),
+  tokenSecret: z.string().optional(),
+  token: z.string().optional(),
   enabled: z.boolean().default(true),
   description: z.string().optional(),
   allowedIndexesAtToken: z.array(z.string()).optional(),

package/src/models/inputcribllakehttp.ts

@@ -171,10 +171,13 @@ export type InputCriblLakeHttpAuthTokensExtMetadatum = {
 
 export type SplunkHecMetadata = {
   enabled?: boolean | undefined;
+  defaultDataset?: string | undefined;
+  allowedIndexesAtToken?: Array<string> | undefined;
 };
 
 export type ElasticsearchMetadata = {
   enabled?: boolean | undefined;
+  defaultDataset?: string | undefined;
 };
 
 export type InputCriblLakeHttpAuthTokensExt = {
@@ -708,10 +711,14 @@ export const SplunkHecMetadata$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   enabled: z.boolean().optional(),
+  defaultDataset: z.string().optional(),
+  allowedIndexesAtToken: z.array(z.string()).optional(),
 });
 /** @internal */
 export type SplunkHecMetadata$Outbound = {
   enabled?: boolean | undefined;
+  defaultDataset?: string | undefined;
+  allowedIndexesAtToken?: Array<string> | undefined;
 };
 
 /** @internal */
@@ -721,6 +728,8 @@ export const SplunkHecMetadata$outboundSchema: z.ZodType<
   SplunkHecMetadata
 > = z.object({
   enabled: z.boolean().optional(),
+  defaultDataset: z.string().optional(),
+  allowedIndexesAtToken: z.array(z.string()).optional(),
 });
 
 export function splunkHecMetadataToJSON(
@@ -747,10 +756,12 @@ export const ElasticsearchMetadata$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   enabled: z.boolean().optional(),
+  defaultDataset: z.string().optional(),
 });
 /** @internal */
 export type ElasticsearchMetadata$Outbound = {
   enabled?: boolean | undefined;
+  defaultDataset?: string | undefined;
 };
 
 /** @internal */
@@ -760,6 +771,7 @@ export const ElasticsearchMetadata$outboundSchema: z.ZodType<
   ElasticsearchMetadata
 > = z.object({
   enabled: z.boolean().optional(),
+  defaultDataset: z.string().optional(),
 });
 
 export function elasticsearchMetadataToJSON(

package/src/models/inputsnmp.ts

@@ -125,11 +125,36 @@ export const AuthenticationProtocol = {
 } as const;
 export type AuthenticationProtocol = OpenEnum<typeof AuthenticationProtocol>;
 
+export const PrivacyProtocol = {
+  /**
+   * None
+   */
+  None: "none",
+  /**
+   * DES
+   */
+  Des: "des",
+  /**
+   * AES128
+   */
+  Aes: "aes",
+  /**
+   * AES256b (Blumenthal)
+   */
+  Aes256b: "aes256b",
+  /**
+   * AES256r (Reeder)
+   */
+  Aes256r: "aes256r",
+} as const;
+export type PrivacyProtocol = OpenEnum<typeof PrivacyProtocol>;
+
 export type V3User = {
   name: string;
   authProtocol?: AuthenticationProtocol | undefined;
-  authKey?: any | undefined;
-  privProtocol?: string | undefined;
+  authKey?: string | undefined;
+  privProtocol?: PrivacyProtocol | undefined;
+  privKey?: string | undefined;
 };
 
 /**
@@ -426,20 +451,42 @@ export const AuthenticationProtocol$outboundSchema: z.ZodType<
   z.string().and(z.custom<Unrecognized<string>>()),
 ]);
 
+/** @internal */
+export const PrivacyProtocol$inboundSchema: z.ZodType<
+  PrivacyProtocol,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(PrivacyProtocol),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
+/** @internal */
+export const PrivacyProtocol$outboundSchema: z.ZodType<
+  PrivacyProtocol,
+  z.ZodTypeDef,
+  PrivacyProtocol
+> = z.union([
+  z.nativeEnum(PrivacyProtocol),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
+
 /** @internal */
 export const V3User$inboundSchema: z.ZodType<V3User, z.ZodTypeDef, unknown> = z
   .object({
     name: z.string(),
     authProtocol: AuthenticationProtocol$inboundSchema.default("none"),
-    authKey: z.any().optional(),
-    privProtocol: z.string().default("none"),
+    authKey: z.string().optional(),
+    privProtocol: PrivacyProtocol$inboundSchema.default("none"),
+    privKey: z.string().optional(),
   });
 /** @internal */
 export type V3User$Outbound = {
   name: string;
   authProtocol: string;
-  authKey?: any | undefined;
+  authKey?: string | undefined;
   privProtocol: string;
+  privKey?: string | undefined;
 };
 
 /** @internal */
@@ -450,8 +497,9 @@ export const V3User$outboundSchema: z.ZodType<
 > = z.object({
   name: z.string(),
   authProtocol: AuthenticationProtocol$outboundSchema.default("none"),
-  authKey: z.any().optional(),
-  privProtocol: z.string().default("none"),
+  authKey: z.string().optional(),
+  privProtocol: PrivacyProtocol$outboundSchema.default("none"),
+  privKey: z.string().optional(),
 });
 
 export function v3UserToJSON(v3User: V3User): string {

package/src/models/inputsplunkhec.ts

@@ -122,8 +122,14 @@ export type InputSplunkHecAuthToken = {
    * Select Manual to enter an auth token directly, or select Secret to use a text secret to authenticate
    */
   authType?: InputSplunkHecAuthenticationMethod | undefined;
-  tokenSecret?: any | undefined;
-  token?: any | undefined;
+  /**
+   * Select or create a stored text secret
+   */
+  tokenSecret?: string | undefined;
+  /**
+   * Shared secret to be provided by any client (Authorization: <token>)
+   */
+  token: string;
   enabled?: boolean | undefined;
   /**
    * Optional token description
@@ -597,8 +603,8 @@ export const InputSplunkHecAuthToken$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   authType: InputSplunkHecAuthenticationMethod$inboundSchema.default("manual"),
-  tokenSecret: z.any().optional(),
-  token: z.any().optional(),
+  tokenSecret: z.string().optional(),
+  token: z.string(),
   enabled: z.boolean().default(true),
   description: z.string().optional(),
   allowedIndexesAtToken: z.array(z.string()).optional(),
@@ -609,8 +615,8 @@ export const InputSplunkHecAuthToken$inboundSchema: z.ZodType<
 /** @internal */
 export type InputSplunkHecAuthToken$Outbound = {
   authType: string;
-  tokenSecret?: any | undefined;
-  token?: any | undefined;
+  tokenSecret?: string | undefined;
+  token: string;
   enabled: boolean;
   description?: string | undefined;
   allowedIndexesAtToken?: Array<string> | undefined;
@@ -624,8 +630,8 @@ export const InputSplunkHecAuthToken$outboundSchema: z.ZodType<
   InputSplunkHecAuthToken
 > = z.object({
   authType: InputSplunkHecAuthenticationMethod$outboundSchema.default("manual"),
-  tokenSecret: z.any().optional(),
-  token: z.any().optional(),
+  tokenSecret: z.string().optional(),
+  token: z.string(),
   enabled: z.boolean().default(true),
   description: z.string().optional(),
   allowedIndexesAtToken: z.array(z.string()).optional(),

package/src/models/inputwef.ts

@@ -210,6 +210,17 @@ export type SubscriptionMetadatum = {
   value: string;
 };
 
+export type Query = {
+  /**
+   * The Path attribute from the relevant XML Select element
+   */
+  path: string;
+  /**
+   * The XPath query inside the relevant XML Select element
+   */
+  queryExpression: string;
+};
+
 export type Subscription = {
   subscriptionName: string;
   /**
@@ -253,6 +264,11 @@ export type Subscription = {
    * Fields to add to events ingested under this subscription
    */
   metadata?: Array<SubscriptionMetadatum> | undefined;
+  queries?: Array<Query> | undefined;
+  /**
+   * The XPath query to use for selecting events
+   */
+  xmlQuery?: string | undefined;
 };
 
 export type InputWefMetadatum = {
@@ -772,6 +788,41 @@ export function subscriptionMetadatumFromJSON(
   );
 }
 
+/** @internal */
+export const Query$inboundSchema: z.ZodType<Query, z.ZodTypeDef, unknown> = z
+  .object({
+    path: z.string(),
+    queryExpression: z.string(),
+  });
+/** @internal */
+export type Query$Outbound = {
+  path: string;
+  queryExpression: string;
+};
+
+/** @internal */
+export const Query$outboundSchema: z.ZodType<
+  Query$Outbound,
+  z.ZodTypeDef,
+  Query
+> = z.object({
+  path: z.string(),
+  queryExpression: z.string(),
+});
+
+export function queryToJSON(query: Query): string {
+  return JSON.stringify(Query$outboundSchema.parse(query));
+}
+export function queryFromJSON(
+  jsonString: string,
+): SafeParseResult<Query, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Query$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Query' from JSON`,
+  );
+}
+
 /** @internal */
 export const Subscription$inboundSchema: z.ZodType<
   Subscription,
@@ -791,6 +842,8 @@ export const Subscription$inboundSchema: z.ZodType<
   querySelector: QueryBuilderMode$inboundSchema.default("simple"),
   metadata: z.array(z.lazy(() => SubscriptionMetadatum$inboundSchema))
     .optional(),
+  queries: z.array(z.lazy(() => Query$inboundSchema)).optional(),
+  xmlQuery: z.string().optional(),
 });
 /** @internal */
 export type Subscription$Outbound = {
@@ -806,6 +859,8 @@ export type Subscription$Outbound = {
   locale: string;
   querySelector: string;
   metadata?: Array<SubscriptionMetadatum$Outbound> | undefined;
+  queries?: Array<Query$Outbound> | undefined;
+  xmlQuery?: string | undefined;
 };
 
 /** @internal */
@@ -827,6 +882,8 @@ export const Subscription$outboundSchema: z.ZodType<
   querySelector: QueryBuilderMode$outboundSchema.default("simple"),
   metadata: z.array(z.lazy(() => SubscriptionMetadatum$outboundSchema))
     .optional(),
+  queries: z.array(z.lazy(() => Query$outboundSchema)).optional(),
+  xmlQuery: z.string().optional(),
 });
 
 export function subscriptionToJSON(subscription: Subscription): string {

package/src/models/inputwiz.ts

@@ -93,6 +93,23 @@ export type InputWizPq = {
   pqControls?: InputWizPqControls | undefined;
 };
 
+export type ManageState = {};
+
+/**
+ * Collector runtime log level
+ */
+export const InputWizLogLevel = {
+  Error: "error",
+  Warn: "warn",
+  Info: "info",
+  Debug: "debug",
+  Silly: "silly",
+} as const;
+/**
+ * Collector runtime log level
+ */
+export type InputWizLogLevel = OpenEnum<typeof InputWizLogLevel>;
+
 export type InputWizContentConfig = {
   /**
    * The name of the Wiz query
@@ -100,6 +117,43 @@ export type InputWizContentConfig = {
   contentType: string;
   contentDescription?: string | undefined;
   enabled?: boolean | undefined;
+  /**
+   * Track collection progress between consecutive scheduled executions
+   */
+  stateTracking?: boolean | undefined;
+  /**
+   * JavaScript expression that defines how to update the state from an event. Use the event's data and the current state to compute the new state. See [Understanding State Expression Fields](https://docs.cribl.io/stream/collectors-rest#state-tracking-expression-fields) for more information.
+   */
+  stateUpdateExpression?: string | undefined;
+  /**
+   * JavaScript expression that defines which state to keep when merging a task's newly reported state with previously saved state. Evaluates `prevState` and `newState` variables, resolving to the state to keep.
+   */
+  stateMergeExpression?: string | undefined;
+  manageState?: ManageState | undefined;
+  /**
+   * Template for POST body to send with the Collect request. Reference global variables, or functions using template params: `${C.vars.myVar}`, or `${Date.now()}`, `${param}`.
+   */
+  contentQuery: string;
+  /**
+   * A cron schedule on which to run this job
+   */
+  cronSchedule?: string | undefined;
+  /**
+   * Earliest time, relative to now. Format supported: [+|-]<time_integer><time_unit>@<snap-to_time_unit> (ex: -1hr, -42m, -42m@h)
+   */
+  earliest?: string | undefined;
+  /**
+   * Latest time, relative to now. Format supported: [+|-]<time_integer><time_unit>@<snap-to_time_unit> (ex: -1hr, -42m, -42m@h)
+   */
+  latest?: string | undefined;
+  /**
+   * Maximum time the job is allowed to run (examples: 30, 45s, 15m). Units default to seconds if not specified. Enter 0 for unlimited time.
+   */
+  jobTimeout?: string | undefined;
+  /**
+   * Collector runtime log level
+   */
+  logLevel?: InputWizLogLevel | undefined;
 };
 
 export type InputWizMetadatum = {
@@ -448,6 +502,55 @@ export function inputWizPqFromJSON(
   );
 }
 
+/** @internal */
+export const ManageState$inboundSchema: z.ZodType<
+  ManageState,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+/** @internal */
+export type ManageState$Outbound = {};
+
+/** @internal */
+export const ManageState$outboundSchema: z.ZodType<
+  ManageState$Outbound,
+  z.ZodTypeDef,
+  ManageState
+> = z.object({});
+
+export function manageStateToJSON(manageState: ManageState): string {
+  return JSON.stringify(ManageState$outboundSchema.parse(manageState));
+}
+export function manageStateFromJSON(
+  jsonString: string,
+): SafeParseResult<ManageState, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ManageState$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ManageState' from JSON`,
+  );
+}
+
+/** @internal */
+export const InputWizLogLevel$inboundSchema: z.ZodType<
+  InputWizLogLevel,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(InputWizLogLevel),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
+/** @internal */
+export const InputWizLogLevel$outboundSchema: z.ZodType<
+  InputWizLogLevel,
+  z.ZodTypeDef,
+  InputWizLogLevel
+> = z.union([
+  z.nativeEnum(InputWizLogLevel),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
+
 /** @internal */
 export const InputWizContentConfig$inboundSchema: z.ZodType<
   InputWizContentConfig,
@@ -457,12 +560,36 @@ export const InputWizContentConfig$inboundSchema: z.ZodType<
   contentType: z.string(),
   contentDescription: z.string().optional(),
   enabled: z.boolean().default(false),
+  stateTracking: z.boolean().default(false),
+  stateUpdateExpression: z.string().default(
+    "__timestampExtracted !== false && {latestTime: (state.latestTime || 0) > _time ? state.latestTime : _time}",
+  ),
+  stateMergeExpression: z.string().default(
+    "prevState.latestTime > newState.latestTime ? prevState : newState",
+  ),
+  manageState: z.lazy(() => ManageState$inboundSchema).optional(),
+  contentQuery: z.string(),
+  cronSchedule: z.string().default("0 */12 * * *"),
+  earliest: z.string().default("-12h@h"),
+  latest: z.string().default("now"),
+  jobTimeout: z.string().default("0"),
+  logLevel: InputWizLogLevel$inboundSchema.default("info"),
 });
 /** @internal */
 export type InputWizContentConfig$Outbound = {
   contentType: string;
   contentDescription?: string | undefined;
   enabled: boolean;
+  stateTracking: boolean;
+  stateUpdateExpression: string;
+  stateMergeExpression: string;
+  manageState?: ManageState$Outbound | undefined;
+  contentQuery: string;
+  cronSchedule: string;
+  earliest: string;
+  latest: string;
+  jobTimeout: string;
+  logLevel: string;
 };
 
 /** @internal */
@@ -474,6 +601,20 @@ export const InputWizContentConfig$outboundSchema: z.ZodType<
   contentType: z.string(),
   contentDescription: z.string().optional(),
   enabled: z.boolean().default(false),
+  stateTracking: z.boolean().default(false),
+  stateUpdateExpression: z.string().default(
+    "__timestampExtracted !== false && {latestTime: (state.latestTime || 0) > _time ? state.latestTime : _time}",
+  ),
+  stateMergeExpression: z.string().default(
+    "prevState.latestTime > newState.latestTime ? prevState : newState",
+  ),
+  manageState: z.lazy(() => ManageState$outboundSchema).optional(),
+  contentQuery: z.string(),
+  cronSchedule: z.string().default("0 */12 * * *"),
+  earliest: z.string().default("-12h@h"),
+  latest: z.string().default("now"),
+  jobTimeout: z.string().default("0"),
+  logLevel: InputWizLogLevel$outboundSchema.default("info"),
 });
 
 export function inputWizContentConfigToJSON(

package/src/models/inputzscalerhec.ts

@@ -122,8 +122,14 @@ export type InputZscalerHecAuthToken = {
    * Select Manual to enter an auth token directly, or select Secret to use a text secret to authenticate
    */
   authType?: InputZscalerHecAuthenticationMethod | undefined;
-  tokenSecret?: any | undefined;
-  token?: any | undefined;
+  /**
+   * Select or create a stored text secret
+   */
+  tokenSecret?: string | undefined;
+  /**
+   * Shared secret to be provided by any client (Authorization: <token>)
+   */
+  token: string;
   enabled?: boolean | undefined;
   description?: string | undefined;
   /**
@@ -574,8 +580,8 @@ export const InputZscalerHecAuthToken$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   authType: InputZscalerHecAuthenticationMethod$inboundSchema.default("manual"),
-  tokenSecret: z.any().optional(),
-  token: z.any().optional(),
+  tokenSecret: z.string().optional(),
+  token: z.string(),
   enabled: z.boolean().default(true),
   description: z.string().optional(),
   allowedIndexesAtToken: z.array(z.string()).optional(),
@@ -586,8 +592,8 @@ export const InputZscalerHecAuthToken$inboundSchema: z.ZodType<
 /** @internal */
 export type InputZscalerHecAuthToken$Outbound = {
   authType: string;
-  tokenSecret?: any | undefined;
-  token?: any | undefined;
+  tokenSecret?: string | undefined;
+  token: string;
   enabled: boolean;
   description?: string | undefined;
   allowedIndexesAtToken?: Array<string> | undefined;
@@ -603,8 +609,8 @@ export const InputZscalerHecAuthToken$outboundSchema: z.ZodType<
   authType: InputZscalerHecAuthenticationMethod$outboundSchema.default(
     "manual",
   ),
-  tokenSecret: z.any().optional(),
-  token: z.any().optional(),
+  tokenSecret: z.string().optional(),
+  token: z.string(),
   enabled: z.boolean().default(true),
   description: z.string().optional(),
   allowedIndexesAtToken: z.array(z.string()).optional(),