@meetkai/mka1 0.54.48 → 0.54.49

package/src/models/components/featureflagoverride.ts

@@ -0,0 +1,62 @@
+/*
+ * 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 FeatureFlagOverride = {
+  enabled: boolean;
+  identity: string;
+  /**
+   * Any JSON value; its shape is constrained by the flag's value_type.
+   */
+  value?: any | undefined;
+};
+
+/** @internal */
+export const FeatureFlagOverride$inboundSchema: z.ZodType<
+  FeatureFlagOverride,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  enabled: z.boolean(),
+  identity: z.string(),
+  value: z.any().optional(),
+});
+/** @internal */
+export type FeatureFlagOverride$Outbound = {
+  enabled: boolean;
+  identity: string;
+  value?: any | undefined;
+};
+
+/** @internal */
+export const FeatureFlagOverride$outboundSchema: z.ZodType<
+  FeatureFlagOverride$Outbound,
+  z.ZodTypeDef,
+  FeatureFlagOverride
+> = z.object({
+  enabled: z.boolean(),
+  identity: z.string(),
+  value: z.any().optional(),
+});
+
+export function featureFlagOverrideToJSON(
+  featureFlagOverride: FeatureFlagOverride,
+): string {
+  return JSON.stringify(
+    FeatureFlagOverride$outboundSchema.parse(featureFlagOverride),
+  );
+}
+export function featureFlagOverrideFromJSON(
+  jsonString: string,
+): SafeParseResult<FeatureFlagOverride, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FeatureFlagOverride$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FeatureFlagOverride' from JSON`,
+  );
+}

package/src/models/components/featureflagrule.ts

@@ -0,0 +1,83 @@
+/*
+ * 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 {
+  FeatureFlagCondition,
+  FeatureFlagCondition$inboundSchema,
+  FeatureFlagCondition$Outbound,
+  FeatureFlagCondition$outboundSchema,
+} from "./featureflagcondition.js";
+
+export type FeatureFlagRule = {
+  conditions: Array<FeatureFlagCondition>;
+  description?: string | undefined;
+  enabled: boolean;
+  rolloutPercentage?: number | undefined;
+  /**
+   * Any JSON value; its shape is constrained by the flag's value_type.
+   */
+  value?: any | undefined;
+};
+
+/** @internal */
+export const FeatureFlagRule$inboundSchema: z.ZodType<
+  FeatureFlagRule,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  conditions: z.array(FeatureFlagCondition$inboundSchema),
+  description: z.string().optional(),
+  enabled: z.boolean(),
+  rollout_percentage: z.number().int().default(100),
+  value: z.any().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "rollout_percentage": "rolloutPercentage",
+  });
+});
+/** @internal */
+export type FeatureFlagRule$Outbound = {
+  conditions: Array<FeatureFlagCondition$Outbound>;
+  description?: string | undefined;
+  enabled: boolean;
+  rollout_percentage: number;
+  value?: any | undefined;
+};
+
+/** @internal */
+export const FeatureFlagRule$outboundSchema: z.ZodType<
+  FeatureFlagRule$Outbound,
+  z.ZodTypeDef,
+  FeatureFlagRule
+> = z.object({
+  conditions: z.array(FeatureFlagCondition$outboundSchema),
+  description: z.string().optional(),
+  enabled: z.boolean(),
+  rolloutPercentage: z.number().int().default(100),
+  value: z.any().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    rolloutPercentage: "rollout_percentage",
+  });
+});
+
+export function featureFlagRuleToJSON(
+  featureFlagRule: FeatureFlagRule,
+): string {
+  return JSON.stringify(FeatureFlagRule$outboundSchema.parse(featureFlagRule));
+}
+export function featureFlagRuleFromJSON(
+  jsonString: string,
+): SafeParseResult<FeatureFlagRule, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FeatureFlagRule$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FeatureFlagRule' from JSON`,
+  );
+}

package/src/models/components/featureflagstate.ts

@@ -0,0 +1,104 @@
+/*
+ * 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 {
+  FeatureFlagOverride,
+  FeatureFlagOverride$inboundSchema,
+  FeatureFlagOverride$Outbound,
+  FeatureFlagOverride$outboundSchema,
+} from "./featureflagoverride.js";
+import {
+  FeatureFlagRule,
+  FeatureFlagRule$inboundSchema,
+  FeatureFlagRule$Outbound,
+  FeatureFlagRule$outboundSchema,
+} from "./featureflagrule.js";
+
+export type FeatureFlagState = {
+  enabled: boolean;
+  overrides: Array<FeatureFlagOverride>;
+  rolloutPercentage: number;
+  rules: Array<FeatureFlagRule>;
+  /**
+   * Any JSON value; its shape is constrained by the flag's value_type.
+   */
+  value?: any | undefined;
+  updatedAt: Date;
+  /**
+   * Opaque revision token. Send it back as `If-Match` on the next write to that state so a concurrent edit is refused rather than silently overwritten. Compare and echo it; never parse it.
+   */
+  version: string;
+};
+
+/** @internal */
+export const FeatureFlagState$inboundSchema: z.ZodType<
+  FeatureFlagState,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  enabled: z.boolean(),
+  overrides: z.array(FeatureFlagOverride$inboundSchema),
+  rollout_percentage: z.number().int(),
+  rules: z.array(FeatureFlagRule$inboundSchema),
+  value: z.any().optional(),
+  updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  version: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "rollout_percentage": "rolloutPercentage",
+    "updated_at": "updatedAt",
+  });
+});
+/** @internal */
+export type FeatureFlagState$Outbound = {
+  enabled: boolean;
+  overrides: Array<FeatureFlagOverride$Outbound>;
+  rollout_percentage: number;
+  rules: Array<FeatureFlagRule$Outbound>;
+  value?: any | undefined;
+  updated_at: string;
+  version: string;
+};
+
+/** @internal */
+export const FeatureFlagState$outboundSchema: z.ZodType<
+  FeatureFlagState$Outbound,
+  z.ZodTypeDef,
+  FeatureFlagState
+> = z.object({
+  enabled: z.boolean(),
+  overrides: z.array(FeatureFlagOverride$outboundSchema),
+  rolloutPercentage: z.number().int(),
+  rules: z.array(FeatureFlagRule$outboundSchema),
+  value: z.any().optional(),
+  updatedAt: z.date().transform(v => v.toISOString()),
+  version: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    rolloutPercentage: "rollout_percentage",
+    updatedAt: "updated_at",
+  });
+});
+
+export function featureFlagStateToJSON(
+  featureFlagState: FeatureFlagState,
+): string {
+  return JSON.stringify(
+    FeatureFlagState$outboundSchema.parse(featureFlagState),
+  );
+}
+export function featureFlagStateFromJSON(
+  jsonString: string,
+): SafeParseResult<FeatureFlagState, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FeatureFlagState$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FeatureFlagState' from JSON`,
+  );
+}

package/src/models/components/featureflagstateinput.ts

@@ -0,0 +1,91 @@
+/*
+ * 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 {
+  FeatureFlagOverride,
+  FeatureFlagOverride$inboundSchema,
+  FeatureFlagOverride$Outbound,
+  FeatureFlagOverride$outboundSchema,
+} from "./featureflagoverride.js";
+import {
+  FeatureFlagRule,
+  FeatureFlagRule$inboundSchema,
+  FeatureFlagRule$Outbound,
+  FeatureFlagRule$outboundSchema,
+} from "./featureflagrule.js";
+
+export type FeatureFlagStateInput = {
+  enabled: boolean;
+  overrides: Array<FeatureFlagOverride>;
+  rolloutPercentage: number;
+  rules: Array<FeatureFlagRule>;
+  /**
+   * Any JSON value; its shape is constrained by the flag's value_type.
+   */
+  value?: any | undefined;
+};
+
+/** @internal */
+export const FeatureFlagStateInput$inboundSchema: z.ZodType<
+  FeatureFlagStateInput,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  enabled: z.boolean(),
+  overrides: z.array(FeatureFlagOverride$inboundSchema),
+  rollout_percentage: z.number().int(),
+  rules: z.array(FeatureFlagRule$inboundSchema),
+  value: z.any().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "rollout_percentage": "rolloutPercentage",
+  });
+});
+/** @internal */
+export type FeatureFlagStateInput$Outbound = {
+  enabled: boolean;
+  overrides: Array<FeatureFlagOverride$Outbound>;
+  rollout_percentage: number;
+  rules: Array<FeatureFlagRule$Outbound>;
+  value?: any | undefined;
+};
+
+/** @internal */
+export const FeatureFlagStateInput$outboundSchema: z.ZodType<
+  FeatureFlagStateInput$Outbound,
+  z.ZodTypeDef,
+  FeatureFlagStateInput
+> = z.object({
+  enabled: z.boolean(),
+  overrides: z.array(FeatureFlagOverride$outboundSchema),
+  rolloutPercentage: z.number().int(),
+  rules: z.array(FeatureFlagRule$outboundSchema),
+  value: z.any().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    rolloutPercentage: "rollout_percentage",
+  });
+});
+
+export function featureFlagStateInputToJSON(
+  featureFlagStateInput: FeatureFlagStateInput,
+): string {
+  return JSON.stringify(
+    FeatureFlagStateInput$outboundSchema.parse(featureFlagStateInput),
+  );
+}
+export function featureFlagStateInputFromJSON(
+  jsonString: string,
+): SafeParseResult<FeatureFlagStateInput, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FeatureFlagStateInput$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FeatureFlagStateInput' from JSON`,
+  );
+}

package/src/models/components/featureflagstatesummary.ts

@@ -0,0 +1,76 @@
+/*
+ * 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";
+
+export type FeatureFlagStateSummary = {
+  enabled: boolean;
+  overrideCount: number;
+  rolloutPercentage: number;
+  ruleCount: number;
+};
+
+/** @internal */
+export const FeatureFlagStateSummary$inboundSchema: z.ZodType<
+  FeatureFlagStateSummary,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  enabled: z.boolean(),
+  override_count: z.number().int(),
+  rollout_percentage: z.number().int(),
+  rule_count: z.number().int(),
+}).transform((v) => {
+  return remap$(v, {
+    "override_count": "overrideCount",
+    "rollout_percentage": "rolloutPercentage",
+    "rule_count": "ruleCount",
+  });
+});
+/** @internal */
+export type FeatureFlagStateSummary$Outbound = {
+  enabled: boolean;
+  override_count: number;
+  rollout_percentage: number;
+  rule_count: number;
+};
+
+/** @internal */
+export const FeatureFlagStateSummary$outboundSchema: z.ZodType<
+  FeatureFlagStateSummary$Outbound,
+  z.ZodTypeDef,
+  FeatureFlagStateSummary
+> = z.object({
+  enabled: z.boolean(),
+  overrideCount: z.number().int(),
+  rolloutPercentage: z.number().int(),
+  ruleCount: z.number().int(),
+}).transform((v) => {
+  return remap$(v, {
+    overrideCount: "override_count",
+    rolloutPercentage: "rollout_percentage",
+    ruleCount: "rule_count",
+  });
+});
+
+export function featureFlagStateSummaryToJSON(
+  featureFlagStateSummary: FeatureFlagStateSummary,
+): string {
+  return JSON.stringify(
+    FeatureFlagStateSummary$outboundSchema.parse(featureFlagStateSummary),
+  );
+}
+export function featureFlagStateSummaryFromJSON(
+  jsonString: string,
+): SafeParseResult<FeatureFlagStateSummary, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FeatureFlagStateSummary$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FeatureFlagStateSummary' from JSON`,
+  );
+}

package/src/models/components/featureflagupdaterequest.ts

@@ -0,0 +1,71 @@
+/*
+ * 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";
+
+export type FeatureFlagUpdateRequest = {
+  /**
+   * Any JSON value; its shape is constrained by the flag's value_type.
+   */
+  defaultValue?: any | undefined;
+  description?: string | undefined;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const FeatureFlagUpdateRequest$inboundSchema: z.ZodType<
+  FeatureFlagUpdateRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  default_value: z.any().optional(),
+  description: z.string().optional(),
+  name: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "default_value": "defaultValue",
+  });
+});
+/** @internal */
+export type FeatureFlagUpdateRequest$Outbound = {
+  default_value?: any | undefined;
+  description?: string | undefined;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const FeatureFlagUpdateRequest$outboundSchema: z.ZodType<
+  FeatureFlagUpdateRequest$Outbound,
+  z.ZodTypeDef,
+  FeatureFlagUpdateRequest
+> = z.object({
+  defaultValue: z.any().optional(),
+  description: z.string().optional(),
+  name: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    defaultValue: "default_value",
+  });
+});
+
+export function featureFlagUpdateRequestToJSON(
+  featureFlagUpdateRequest: FeatureFlagUpdateRequest,
+): string {
+  return JSON.stringify(
+    FeatureFlagUpdateRequest$outboundSchema.parse(featureFlagUpdateRequest),
+  );
+}
+export function featureFlagUpdateRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<FeatureFlagUpdateRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FeatureFlagUpdateRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FeatureFlagUpdateRequest' from JSON`,
+  );
+}

package/src/models/components/featureflagvaluetype.ts

@@ -0,0 +1,23 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const FeatureFlagValueType = {
+  Boolean: "boolean",
+  String: "string",
+  Number: "number",
+  Json: "json",
+} as const;
+export type FeatureFlagValueType = ClosedEnum<typeof FeatureFlagValueType>;
+
+/** @internal */
+export const FeatureFlagValueType$inboundSchema: z.ZodNativeEnum<
+  typeof FeatureFlagValueType
+> = z.nativeEnum(FeatureFlagValueType);
+/** @internal */
+export const FeatureFlagValueType$outboundSchema: z.ZodNativeEnum<
+  typeof FeatureFlagValueType
+> = FeatureFlagValueType$inboundSchema;

package/src/models/components/index.ts

@@ -299,6 +299,27 @@ export * from "./experiment.js";
 export * from "./extractgroupby.js";
 export * from "./extractionresponse.js";
 export * from "./extractionschema.js";
+export * from "./featureflagauditentry.js";
+export * from "./featureflagauditpage.js";
+export * from "./featureflagcondition.js";
+export * from "./featureflagcreaterequest.js";
+export * from "./featureflagdetail.js";
+export * from "./featureflagenvironment.js";
+export * from "./featureflagenvironmentcreaterequest.js";
+export * from "./featureflagenvironmentupdaterequest.js";
+export * from "./featureflagevaluaterequest.js";
+export * from "./featureflagevaluateresponse.js";
+export * from "./featureflagevaluation.js";
+export * from "./featureflagevaluationkeyresponse.js";
+export * from "./featureflaglistitem.js";
+export * from "./featureflagoperator.js";
+export * from "./featureflagoverride.js";
+export * from "./featureflagrule.js";
+export * from "./featureflagstate.js";
+export * from "./featureflagstateinput.js";
+export * from "./featureflagstatesummary.js";
+export * from "./featureflagupdaterequest.js";
+export * from "./featureflagvaluetype.js";
 export * from "./file.js";
 export * from "./filecitation.js";
 export * from "./filecontentitem.js";

package/src/models/errors/featureflagerror.ts

@@ -0,0 +1,113 @@
+/*
+ * 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 { ClosedEnum } from "../../types/enums.js";
+import { SDKError } from "./sdkerror.js";
+
+export const FeatureFlagErrorError = {
+  BadRequest: "bad_request",
+  AuthenticationRequired: "authentication_required",
+  Forbidden: "forbidden",
+  NotFound: "not_found",
+  Conflict: "conflict",
+  PreconditionFailed: "precondition_failed",
+  MethodNotAllowed: "method_not_allowed",
+  Internal: "internal",
+} as const;
+export type FeatureFlagErrorError = ClosedEnum<typeof FeatureFlagErrorError>;
+
+/**
+ * Authentication is missing or invalid
+ */
+export type FeatureFlagErrorData = {
+  error: FeatureFlagErrorError;
+  message: string;
+  requestId: string;
+};
+
+/**
+ * Authentication is missing or invalid
+ */
+export class FeatureFlagError extends SDKError {
+  error: FeatureFlagErrorError;
+  requestId: string;
+
+  /** The original data that was passed to this error instance. */
+  data$: FeatureFlagErrorData;
+
+  constructor(
+    err: FeatureFlagErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.message || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    this.error = err.error;
+    this.requestId = err.requestId;
+
+    this.name = "FeatureFlagError";
+  }
+}
+
+/** @internal */
+export const FeatureFlagErrorError$inboundSchema: z.ZodNativeEnum<
+  typeof FeatureFlagErrorError
+> = z.nativeEnum(FeatureFlagErrorError);
+/** @internal */
+export const FeatureFlagErrorError$outboundSchema: z.ZodNativeEnum<
+  typeof FeatureFlagErrorError
+> = FeatureFlagErrorError$inboundSchema;
+
+/** @internal */
+export const FeatureFlagError$inboundSchema: z.ZodType<
+  FeatureFlagError,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  error: FeatureFlagErrorError$inboundSchema,
+  message: z.string(),
+  request_id: z.string(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
+})
+  .transform((v) => {
+    const remapped = remap$(v, {
+      "request_id": "requestId",
+    });
+
+    return new FeatureFlagError(remapped, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  });
+
+/** @internal */
+export type FeatureFlagError$Outbound = {
+  error: string;
+  message: string;
+  request_id: string;
+};
+
+/** @internal */
+export const FeatureFlagError$outboundSchema: z.ZodType<
+  FeatureFlagError$Outbound,
+  z.ZodTypeDef,
+  FeatureFlagError
+> = z.instanceof(FeatureFlagError)
+  .transform(v => v.data$)
+  .pipe(
+    z.object({
+      error: FeatureFlagErrorError$outboundSchema,
+      message: z.string(),
+      requestId: z.string(),
+    }).transform((v) => {
+      return remap$(v, {
+        requestId: "request_id",
+      });
+    }),
+  );

package/src/models/errors/index.ts

@@ -17,6 +17,7 @@ export * from "./deleteteam.js";
 export * from "./errorenvelope.js";
 export * from "./exchangeapikeytoken.js";
 export * from "./exchangesessiontoken.js";
+export * from "./featureflagerror.js";
 export * from "./getclusterinviteinfo.js";
 export * from "./getclusterorg.js";
 export * from "./getfilecontent.js";