cribl-control-plane 0.5.0-beta.3 → 0.5.0-rc.1

package/src/models/functiondnslookup.ts

@@ -4,13 +4,154 @@
 
 import * as z from "zod/v3";
 import { remap as remap$ } from "../lib/primitives.js";
-import { safeParse } from "../lib/schemas.js";
+import {
+  collectExtraKeys as collectExtraKeys$,
+  safeParse,
+} from "../lib/schemas.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 {
-  FunctionConfSchemaDnsLookup,
-  FunctionConfSchemaDnsLookup$inboundSchema,
-} from "./functionconfschemadnslookup.js";
+
+/**
+ * The DNS record type (RR) to return. Defaults to 'A'.
+ */
+export const ResourceRecordType = {
+  /**
+   * A
+   */
+  A: "A",
+  /**
+   * AAAA
+   */
+  Aaaa: "AAAA",
+  /**
+   * ANY
+   */
+  Any: "ANY",
+  /**
+   * CNAME
+   */
+  Cname: "CNAME",
+  /**
+   * MX
+   */
+  Mx: "MX",
+  /**
+   * NAPTR
+   */
+  Naptr: "NAPTR",
+  /**
+   * NS
+   */
+  Ns: "NS",
+  /**
+   * PTR
+   */
+  Ptr: "PTR",
+  /**
+   * SOA
+   */
+  Soa: "SOA",
+  /**
+   * SRV
+   */
+  Srv: "SRV",
+  /**
+   * TXT
+   */
+  Txt: "TXT",
+} as const;
+/**
+ * The DNS record type (RR) to return. Defaults to 'A'.
+ */
+export type ResourceRecordType = OpenEnum<typeof ResourceRecordType>;
+
+export type DnsLookupField = {
+  inFieldName?: string | undefined;
+  /**
+   * The DNS record type (RR) to return. Defaults to 'A'.
+   */
+  resourceRecordType?: ResourceRecordType | undefined;
+  /**
+   * Name of field to add lookup results to. Leave blank to overwrite the lookup field.
+   */
+  outFieldName?: string | undefined;
+};
+
+export type ReverseLookupField = {
+  /**
+   * Name of the field containing the IP to look up. If the field value is not in IPv4 or IPv6 format, the lookup is skipped.
+   */
+  inFieldName?: string | undefined;
+  /**
+   * Name of field to add the resolved domain to. Leave blank to overwrite the lookup field.
+   */
+  outFieldName?: string | undefined;
+};
+
+export const LogLevelForFailedLookups = {
+  /**
+   * silly
+   */
+  Silly: "silly",
+  /**
+   * debug
+   */
+  Debug: "debug",
+  /**
+   * info
+   */
+  Info: "info",
+  /**
+   * warn
+   */
+  Warn: "warn",
+  /**
+   * error
+   */
+  Error: "error",
+} as const;
+export type LogLevelForFailedLookups = OpenEnum<
+  typeof LogLevelForFailedLookups
+>;
+
+export type FunctionDnsLookupSchema = {
+  /**
+   * List of field names on which to perform DNS lookup
+   */
+  dnsLookupFields?: Array<DnsLookupField> | undefined;
+  /**
+   * List of field names on which to perform reverse DNS lookup
+   */
+  reverseLookupFields?: Array<ReverseLookupField> | undefined;
+  /**
+   * IPs, in RFC 5952 format, of the DNS servers to use for resolution. Examples: IPv4 1.1.1.1, 4.2.2.2:53, or IPv6 [2001:4860:4860::8888], [2001:4860:4860::8888]:1053. If not specified, system's DNS will be used.
+   */
+  dnsServers?: Array<string> | undefined;
+  /**
+   * How frequently to expire and refetch DNS cache. Use 0 to disable.
+   */
+  cacheTTL?: number | undefined;
+  /**
+   * The maximum number of DNS resolutions to be cached locally. Leave at default unless you understand the implications of changing.
+   */
+  maxCacheSize?: number | undefined;
+  /**
+   * Attempt to resolve DNS short names using the search or domain directive from /etc/resolv.conf
+   */
+  useResolvConf?: boolean | undefined;
+  /**
+   * If unable to resolve a DNS short name, make a DNS.lookup() call to resolve it. Caution: This might degrade performance in unrelated areas of @{product}.
+   */
+  lookupFallback?: boolean | undefined;
+  /**
+   * Specify fallback values for the DNS resolver to use when it cannot resolve a DNS short name
+   */
+  domainOverrides?: Array<string> | undefined;
+  lookupFailLogLevel?: LogLevelForFailedLookups | undefined;
+  additionalProperties?: { [k: string]: any } | undefined;
+};
 
 export type FunctionDnsLookup = {
   filename: string;
@@ -26,9 +167,97 @@ export type FunctionDnsLookup = {
   sync?: boolean | undefined;
   uischema: { [k: string]: any };
   version: string;
-  schema?: FunctionConfSchemaDnsLookup | undefined;
+  schema?: FunctionDnsLookupSchema | undefined;
 };
 
+/** @internal */
+export const ResourceRecordType$inboundSchema: z.ZodType<
+  ResourceRecordType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(ResourceRecordType);
+
+/** @internal */
+export const DnsLookupField$inboundSchema: z.ZodType<
+  DnsLookupField,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  inFieldName: z.string().optional(),
+  resourceRecordType: ResourceRecordType$inboundSchema.default("A"),
+  outFieldName: z.string().optional(),
+});
+
+export function dnsLookupFieldFromJSON(
+  jsonString: string,
+): SafeParseResult<DnsLookupField, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DnsLookupField$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DnsLookupField' from JSON`,
+  );
+}
+
+/** @internal */
+export const ReverseLookupField$inboundSchema: z.ZodType<
+  ReverseLookupField,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  inFieldName: z.string().optional(),
+  outFieldName: z.string().optional(),
+});
+
+export function reverseLookupFieldFromJSON(
+  jsonString: string,
+): SafeParseResult<ReverseLookupField, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ReverseLookupField$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ReverseLookupField' from JSON`,
+  );
+}
+
+/** @internal */
+export const LogLevelForFailedLookups$inboundSchema: z.ZodType<
+  LogLevelForFailedLookups,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(LogLevelForFailedLookups);
+
+/** @internal */
+export const FunctionDnsLookupSchema$inboundSchema: z.ZodType<
+  FunctionDnsLookupSchema,
+  z.ZodTypeDef,
+  unknown
+> = collectExtraKeys$(
+  z.object({
+    dnsLookupFields: z.array(z.lazy(() => DnsLookupField$inboundSchema))
+      .optional(),
+    reverseLookupFields: z.array(z.lazy(() => ReverseLookupField$inboundSchema))
+      .optional(),
+    dnsServers: z.array(z.string()).optional(),
+    cacheTTL: z.number().default(30),
+    maxCacheSize: z.number().default(5000),
+    useResolvConf: z.boolean().default(false),
+    lookupFallback: z.boolean().default(false),
+    domainOverrides: z.array(z.string()).optional(),
+    lookupFailLogLevel: LogLevelForFailedLookups$inboundSchema.default("error"),
+  }).catchall(z.any()),
+  "additionalProperties",
+  true,
+);
+
+export function functionDnsLookupSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionDnsLookupSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionDnsLookupSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionDnsLookupSchema' from JSON`,
+  );
+}
+
 /** @internal */
 export const FunctionDnsLookup$inboundSchema: z.ZodType<
   FunctionDnsLookup,
@@ -48,7 +277,7 @@ export const FunctionDnsLookup$inboundSchema: z.ZodType<
   sync: z.boolean().optional(),
   uischema: z.record(z.any()),
   version: z.string(),
-  schema: FunctionConfSchemaDnsLookup$inboundSchema.optional(),
+  schema: z.lazy(() => FunctionDnsLookupSchema$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "__filename": "filename",

package/src/models/functiondrop.ts

@@ -7,10 +7,8 @@ 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 {
-  FunctionConfSchemaDrop,
-  FunctionConfSchemaDrop$inboundSchema,
-} from "./functionconfschemadrop.js";
+
+export type FunctionDropSchema = {};
 
 export type FunctionDrop = {
   filename: string;
@@ -26,9 +24,26 @@ export type FunctionDrop = {
   sync?: boolean | undefined;
   uischema: { [k: string]: any };
   version: string;
-  schema?: FunctionConfSchemaDrop | undefined;
+  schema?: FunctionDropSchema | undefined;
 };
 
+/** @internal */
+export const FunctionDropSchema$inboundSchema: z.ZodType<
+  FunctionDropSchema,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function functionDropSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionDropSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionDropSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionDropSchema' from JSON`,
+  );
+}
+
 /** @internal */
 export const FunctionDrop$inboundSchema: z.ZodType<
   FunctionDrop,
@@ -48,7 +63,7 @@ export const FunctionDrop$inboundSchema: z.ZodType<
   sync: z.boolean().optional(),
   uischema: z.record(z.any()),
   version: z.string(),
-  schema: FunctionConfSchemaDrop$inboundSchema.optional(),
+  schema: z.lazy(() => FunctionDropSchema$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "__filename": "filename",

package/src/models/functiondropdimensions.ts

@@ -7,10 +7,21 @@ 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 {
-  FunctionConfSchemaDropDimensions,
-  FunctionConfSchemaDropDimensions$inboundSchema,
-} from "./functionconfschemadropdimensions.js";
+
+export type FunctionDropDimensionsSchema = {
+  /**
+   * The time span of the tumbling window for aggregating events. Must be a valid time string (such as 10s).
+   */
+  timeWindow?: string | undefined;
+  /**
+   * One or more dimensions to be dropped. Supports wildcard expressions. Warning: Using wildcard '*' causes all dimensions in the event to be dropped.
+   */
+  dropDimensions?: Array<string> | undefined;
+  /**
+   * Flush aggregations when an input stream is closed. If disabled, aggregations are flushed based on Time Window Settings instead.
+   */
+  flushOnInputClose?: boolean | undefined;
+};
 
 export type FunctionDropDimensions = {
   filename: string;
@@ -26,9 +37,30 @@ export type FunctionDropDimensions = {
   sync?: boolean | undefined;
   uischema: { [k: string]: any };
   version: string;
-  schema?: FunctionConfSchemaDropDimensions | undefined;
+  schema?: FunctionDropDimensionsSchema | undefined;
 };
 
+/** @internal */
+export const FunctionDropDimensionsSchema$inboundSchema: z.ZodType<
+  FunctionDropDimensionsSchema,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  timeWindow: z.string().default("10s"),
+  dropDimensions: z.array(z.string()).optional(),
+  flushOnInputClose: z.boolean().default(true),
+});
+
+export function functionDropDimensionsSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionDropDimensionsSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionDropDimensionsSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionDropDimensionsSchema' from JSON`,
+  );
+}
+
 /** @internal */
 export const FunctionDropDimensions$inboundSchema: z.ZodType<
   FunctionDropDimensions,
@@ -48,7 +80,7 @@ export const FunctionDropDimensions$inboundSchema: z.ZodType<
   sync: z.boolean().optional(),
   uischema: z.record(z.any()),
   version: z.string(),
-  schema: FunctionConfSchemaDropDimensions$inboundSchema.optional(),
+  schema: z.lazy(() => FunctionDropDimensionsSchema$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "__filename": "filename",

package/src/models/functiondynamicsampling.ts

@@ -5,12 +5,51 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.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 {
-  FunctionConfSchemaDynamicSampling,
-  FunctionConfSchemaDynamicSampling$inboundSchema,
-} from "./functionconfschemadynamicsampling.js";
+
+/**
+ * Defines how sample rate will be derived: log(previousPeriodCount) or sqrt(previousPeriodCount)
+ */
+export const SampleMode = {
+  /**
+   * Logarithmic
+   */
+  Log: "log",
+  /**
+   * Square Root
+   */
+  Sqrt: "sqrt",
+} as const;
+/**
+ * Defines how sample rate will be derived: log(previousPeriodCount) or sqrt(previousPeriodCount)
+ */
+export type SampleMode = OpenEnum<typeof SampleMode>;
+
+export type FunctionDynamicSamplingSchema = {
+  /**
+   * Defines how sample rate will be derived: log(previousPeriodCount) or sqrt(previousPeriodCount)
+   */
+  mode?: SampleMode | undefined;
+  /**
+   * Expression used to derive sample group key. Example:`${domain}:${status}`. Each sample group will have its own derived sampling rate based on volume. Defaults to `${host}`.
+   */
+  keyExpr?: string | undefined;
+  /**
+   * How often (in seconds) sample rates will be adjusted
+   */
+  samplePeriod?: number | undefined;
+  /**
+   * Minimum number of events that must be received in previous sample period for sampling mode to be applied to current period. If the number of events received for a sample group is less than this minimum, a sample rate of 1:1 is used.
+   */
+  minEvents?: number | undefined;
+  /**
+   * Maximum sampling rate. If computed sampling rate is above this value, it will be limited to this value.
+   */
+  maxSampleRate?: number | undefined;
+};
 
 export type FunctionDynamicSampling = {
   filename: string;
@@ -26,9 +65,39 @@ export type FunctionDynamicSampling = {
   sync?: boolean | undefined;
   uischema: { [k: string]: any };
   version: string;
-  schema?: FunctionConfSchemaDynamicSampling | undefined;
+  schema?: FunctionDynamicSamplingSchema | undefined;
 };
 
+/** @internal */
+export const SampleMode$inboundSchema: z.ZodType<
+  SampleMode,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(SampleMode);
+
+/** @internal */
+export const FunctionDynamicSamplingSchema$inboundSchema: z.ZodType<
+  FunctionDynamicSamplingSchema,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  mode: SampleMode$inboundSchema.default("log"),
+  keyExpr: z.string().default("`${host}`"),
+  samplePeriod: z.number().default(30),
+  minEvents: z.number().default(30),
+  maxSampleRate: z.number().default(100),
+});
+
+export function functionDynamicSamplingSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionDynamicSamplingSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionDynamicSamplingSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionDynamicSamplingSchema' from JSON`,
+  );
+}
+
 /** @internal */
 export const FunctionDynamicSampling$inboundSchema: z.ZodType<
   FunctionDynamicSampling,
@@ -48,7 +117,7 @@ export const FunctionDynamicSampling$inboundSchema: z.ZodType<
   sync: z.boolean().optional(),
   uischema: z.record(z.any()),
   version: z.string(),
-  schema: FunctionConfSchemaDynamicSampling$inboundSchema.optional(),
+  schema: z.lazy(() => FunctionDynamicSamplingSchema$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "__filename": "filename",

package/src/models/functioneval.ts

@@ -7,10 +7,33 @@ 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 {
-  FunctionConfSchemaEval,
-  FunctionConfSchemaEval$inboundSchema,
-} from "./functionconfschemaeval.js";
+
+export type FunctionEvalAdd = {
+  name?: string | undefined;
+  /**
+   * JavaScript expression to compute the value (can be constant)
+   */
+  value: string;
+  /**
+   * Set to No to disable the evaluation of an individual expression
+   */
+  disabled?: boolean | undefined;
+};
+
+export type FunctionEvalSchema = {
+  /**
+   * Set of key-value pairs to evaluate and add/set
+   */
+  add?: Array<FunctionEvalAdd> | undefined;
+  /**
+   * List of fields to keep. Supports * wildcards. Takes precedence over 'Remove fields'.
+   */
+  keep?: Array<string> | undefined;
+  /**
+   * List of fields to remove. Supports * wildcards. Fields that match 'Keep fields' will not be removed. Enclose field names containing special characters in single or double quotes.
+   */
+  remove?: Array<string> | undefined;
+};
 
 export type FunctionEval = {
   filename: string;
@@ -26,9 +49,51 @@ export type FunctionEval = {
   sync?: boolean | undefined;
   uischema: { [k: string]: any };
   version: string;
-  schema?: FunctionConfSchemaEval | undefined;
+  schema?: FunctionEvalSchema | undefined;
 };
 
+/** @internal */
+export const FunctionEvalAdd$inboundSchema: z.ZodType<
+  FunctionEvalAdd,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string().optional(),
+  value: z.string(),
+  disabled: z.boolean().default(false),
+});
+
+export function functionEvalAddFromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionEvalAdd, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionEvalAdd$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionEvalAdd' from JSON`,
+  );
+}
+
+/** @internal */
+export const FunctionEvalSchema$inboundSchema: z.ZodType<
+  FunctionEvalSchema,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  add: z.array(z.lazy(() => FunctionEvalAdd$inboundSchema)).optional(),
+  keep: z.array(z.string()).optional(),
+  remove: z.array(z.string()).optional(),
+});
+
+export function functionEvalSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionEvalSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionEvalSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionEvalSchema' from JSON`,
+  );
+}
+
 /** @internal */
 export const FunctionEval$inboundSchema: z.ZodType<
   FunctionEval,
@@ -48,7 +113,7 @@ export const FunctionEval$inboundSchema: z.ZodType<
   sync: z.boolean().optional(),
   uischema: z.record(z.any()),
   version: z.string(),
-  schema: FunctionConfSchemaEval$inboundSchema.optional(),
+  schema: z.lazy(() => FunctionEvalSchema$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "__filename": "filename",

package/src/models/functioneventbreaker.ts

@@ -5,12 +5,30 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.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 {
-  FunctionConfSchemaEventBreaker,
-  FunctionConfSchemaEventBreaker$inboundSchema,
-} from "./functionconfschemaeventbreaker.js";
+
+export const ExistingOrNew = {
+  /**
+   * Use Existing
+   */
+  Existing: "existing",
+  /**
+   * Create New
+   */
+  New: "new",
+} as const;
+export type ExistingOrNew = OpenEnum<typeof ExistingOrNew>;
+
+export type FunctionEventBreakerSchema = {
+  existingOrNew?: ExistingOrNew | undefined;
+  /**
+   * Add this Function name to the cribl_breaker field
+   */
+  shouldMarkCriblBreaker?: boolean | undefined;
+};
 
 export type FunctionEventBreaker = {
   filename: string;
@@ -26,9 +44,36 @@ export type FunctionEventBreaker = {
   sync?: boolean | undefined;
   uischema: { [k: string]: any };
   version: string;
-  schema?: FunctionConfSchemaEventBreaker | undefined;
+  schema?: FunctionEventBreakerSchema | undefined;
 };
 
+/** @internal */
+export const ExistingOrNew$inboundSchema: z.ZodType<
+  ExistingOrNew,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(ExistingOrNew);
+
+/** @internal */
+export const FunctionEventBreakerSchema$inboundSchema: z.ZodType<
+  FunctionEventBreakerSchema,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  existingOrNew: ExistingOrNew$inboundSchema.default("existing"),
+  shouldMarkCriblBreaker: z.boolean().default(true),
+});
+
+export function functionEventBreakerSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionEventBreakerSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionEventBreakerSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionEventBreakerSchema' from JSON`,
+  );
+}
+
 /** @internal */
 export const FunctionEventBreaker$inboundSchema: z.ZodType<
   FunctionEventBreaker,
@@ -48,7 +93,7 @@ export const FunctionEventBreaker$inboundSchema: z.ZodType<
   sync: z.boolean().optional(),
   uischema: z.record(z.any()),
   version: z.string(),
-  schema: FunctionConfSchemaEventBreaker$inboundSchema.optional(),
+  schema: z.lazy(() => FunctionEventBreakerSchema$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "__filename": "filename",