@raindrop-ai/query 0.1.0

package/src/models/operations/events-facets.ts

@@ -0,0 +1,208 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+
+/**
+ * Field to get facets for
+ */
+export const Field = {
+  EventName: "event_name",
+  UserId: "user_id",
+  Signal: "signal",
+} as const;
+/**
+ * Field to get facets for
+ */
+export type Field = ClosedEnum<typeof Field>;
+
+export type EventsFacetsRequest = {
+  /**
+   * Field to get facets for
+   */
+  field?: Field | undefined;
+  limit?: number | undefined;
+  userId?: string | undefined;
+  eventName?: string | undefined;
+  signal?: string | undefined;
+  timestampGte?: Date | undefined;
+  timestampLt?: Date | undefined;
+};
+
+export type EventsFacetsDetails = {
+  field?: string | undefined;
+  allowedFields?: Array<string> | undefined;
+};
+
+export type EventsFacetsError = {
+  /**
+   * Error code
+   */
+  code: string;
+  /**
+   * Human-readable error message
+   */
+  message: string;
+  details?: EventsFacetsDetails | undefined;
+};
+
+export type EventsFacetsData = {
+  /**
+   * The facet value
+   */
+  value: string;
+  /**
+   * Count of events with this value
+   */
+  count: number;
+};
+
+/**
+ * Facet values
+ */
+export type EventsFacetsResponse = {
+  /**
+   * Facet values with counts
+   */
+  data: Array<EventsFacetsData>;
+};
+
+/** @internal */
+export const Field$outboundSchema: z.ZodMiniEnum<typeof Field> = z.enum(Field);
+
+/** @internal */
+export type EventsFacetsRequest$Outbound = {
+  field: string;
+  limit: number;
+  user_id?: string | undefined;
+  event_name?: string | undefined;
+  signal?: string | undefined;
+  "timestamp.gte"?: string | undefined;
+  "timestamp.lt"?: string | undefined;
+};
+
+/** @internal */
+export const EventsFacetsRequest$outboundSchema: z.ZodMiniType<
+  EventsFacetsRequest$Outbound,
+  EventsFacetsRequest
+> = z.pipe(
+  z.object({
+    field: z._default(Field$outboundSchema, "event_name"),
+    limit: z._default(z.int(), 20),
+    userId: z.optional(z.string()),
+    eventName: z.optional(z.string()),
+    signal: z.optional(z.string()),
+    timestampGte: z.optional(
+      z.pipe(z.date(), z.transform(v => v.toISOString())),
+    ),
+    timestampLt: z.optional(
+      z.pipe(z.date(), z.transform(v => v.toISOString())),
+    ),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      userId: "user_id",
+      eventName: "event_name",
+      timestampGte: "timestamp.gte",
+      timestampLt: "timestamp.lt",
+    });
+  }),
+);
+
+export function eventsFacetsRequestToJSON(
+  eventsFacetsRequest: EventsFacetsRequest,
+): string {
+  return JSON.stringify(
+    EventsFacetsRequest$outboundSchema.parse(eventsFacetsRequest),
+  );
+}
+
+/** @internal */
+export const EventsFacetsDetails$inboundSchema: z.ZodMiniType<
+  EventsFacetsDetails,
+  unknown
+> = z.pipe(
+  z.object({
+    field: types.optional(types.string()),
+    allowed_fields: types.optional(z.array(types.string())),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "allowed_fields": "allowedFields",
+    });
+  }),
+);
+
+export function eventsFacetsDetailsFromJSON(
+  jsonString: string,
+): SafeParseResult<EventsFacetsDetails, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EventsFacetsDetails$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EventsFacetsDetails' from JSON`,
+  );
+}
+
+/** @internal */
+export const EventsFacetsError$inboundSchema: z.ZodMiniType<
+  EventsFacetsError,
+  unknown
+> = z.object({
+  code: types.string(),
+  message: types.string(),
+  details: types.optional(z.lazy(() => EventsFacetsDetails$inboundSchema)),
+});
+
+export function eventsFacetsErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<EventsFacetsError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EventsFacetsError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EventsFacetsError' from JSON`,
+  );
+}
+
+/** @internal */
+export const EventsFacetsData$inboundSchema: z.ZodMiniType<
+  EventsFacetsData,
+  unknown
+> = z.object({
+  value: types.string(),
+  count: types.number(),
+});
+
+export function eventsFacetsDataFromJSON(
+  jsonString: string,
+): SafeParseResult<EventsFacetsData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EventsFacetsData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EventsFacetsData' from JSON`,
+  );
+}
+
+/** @internal */
+export const EventsFacetsResponse$inboundSchema: z.ZodMiniType<
+  EventsFacetsResponse,
+  unknown
+> = z.object({
+  data: z.array(z.lazy(() => EventsFacetsData$inboundSchema)),
+});
+
+export function eventsFacetsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<EventsFacetsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EventsFacetsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EventsFacetsResponse' from JSON`,
+  );
+}

package/src/models/operations/events-get.ts

@@ -0,0 +1,206 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+
+export type EventsGetRequest = {
+  id: string;
+};
+
+export type EventsGetDetails = {
+  field?: string | undefined;
+  allowedFields?: Array<string> | undefined;
+};
+
+export type EventsGetError = {
+  /**
+   * Error code
+   */
+  code: string;
+  /**
+   * Human-readable error message
+   */
+  message: string;
+  details?: EventsGetDetails | undefined;
+};
+
+export type EventsGetSignal = {
+  id: string;
+  name: string;
+  score?: number | undefined;
+};
+
+export type EventsGetData = {
+  id: string;
+  eventName: string;
+  userId: string | null;
+  convoId: string | null;
+  timestamp: Date;
+  receivedAt?: Date | undefined;
+  userInput: string | null;
+  assistantOutput: string | null;
+  signals?: Array<EventsGetSignal> | undefined;
+  properties?: { [k: string]: any | null } | undefined;
+  relevanceScore?: number | undefined;
+};
+
+/**
+ * Event details
+ */
+export type EventsGetResponse = {
+  data: EventsGetData;
+};
+
+/** @internal */
+export type EventsGetRequest$Outbound = {
+  id: string;
+};
+
+/** @internal */
+export const EventsGetRequest$outboundSchema: z.ZodMiniType<
+  EventsGetRequest$Outbound,
+  EventsGetRequest
+> = z.object({
+  id: z.string(),
+});
+
+export function eventsGetRequestToJSON(
+  eventsGetRequest: EventsGetRequest,
+): string {
+  return JSON.stringify(
+    EventsGetRequest$outboundSchema.parse(eventsGetRequest),
+  );
+}
+
+/** @internal */
+export const EventsGetDetails$inboundSchema: z.ZodMiniType<
+  EventsGetDetails,
+  unknown
+> = z.pipe(
+  z.object({
+    field: types.optional(types.string()),
+    allowed_fields: types.optional(z.array(types.string())),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "allowed_fields": "allowedFields",
+    });
+  }),
+);
+
+export function eventsGetDetailsFromJSON(
+  jsonString: string,
+): SafeParseResult<EventsGetDetails, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EventsGetDetails$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EventsGetDetails' from JSON`,
+  );
+}
+
+/** @internal */
+export const EventsGetError$inboundSchema: z.ZodMiniType<
+  EventsGetError,
+  unknown
+> = z.object({
+  code: types.string(),
+  message: types.string(),
+  details: types.optional(z.lazy(() => EventsGetDetails$inboundSchema)),
+});
+
+export function eventsGetErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<EventsGetError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EventsGetError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EventsGetError' from JSON`,
+  );
+}
+
+/** @internal */
+export const EventsGetSignal$inboundSchema: z.ZodMiniType<
+  EventsGetSignal,
+  unknown
+> = z.object({
+  id: types.string(),
+  name: types.string(),
+  score: types.optional(types.number()),
+});
+
+export function eventsGetSignalFromJSON(
+  jsonString: string,
+): SafeParseResult<EventsGetSignal, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EventsGetSignal$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EventsGetSignal' from JSON`,
+  );
+}
+
+/** @internal */
+export const EventsGetData$inboundSchema: z.ZodMiniType<
+  EventsGetData,
+  unknown
+> = z.pipe(
+  z.object({
+    id: types.string(),
+    event_name: types.string(),
+    user_id: types.nullable(types.string()),
+    convo_id: types.nullable(types.string()),
+    timestamp: types.date(),
+    received_at: types.optional(types.date()),
+    user_input: types.nullable(types.string()),
+    assistant_output: types.nullable(types.string()),
+    signals: types.optional(
+      z.array(z.lazy(() => EventsGetSignal$inboundSchema)),
+    ),
+    properties: types.optional(z.record(z.string(), types.nullable(z.any()))),
+    relevance_score: types.optional(types.number()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "event_name": "eventName",
+      "user_id": "userId",
+      "convo_id": "convoId",
+      "received_at": "receivedAt",
+      "user_input": "userInput",
+      "assistant_output": "assistantOutput",
+      "relevance_score": "relevanceScore",
+    });
+  }),
+);
+
+export function eventsGetDataFromJSON(
+  jsonString: string,
+): SafeParseResult<EventsGetData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EventsGetData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EventsGetData' from JSON`,
+  );
+}
+
+/** @internal */
+export const EventsGetResponse$inboundSchema: z.ZodMiniType<
+  EventsGetResponse,
+  unknown
+> = z.object({
+  data: z.lazy(() => EventsGetData$inboundSchema),
+});
+
+export function eventsGetResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<EventsGetResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EventsGetResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EventsGetResponse' from JSON`,
+  );
+}