@raindrop-ai/query 0.1.0

package/src/models/operations/users-list.ts

@@ -0,0 +1,477 @@
+/*
+ * 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 { smartUnion } from "../../types/smart-union.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+
+export type UsersListUserId = {
+  eq?: string | undefined;
+  neq?: string | undefined;
+  startsWith?: string | undefined;
+  endsWith?: string | undefined;
+  contains?: string | undefined;
+};
+
+/**
+ * Filter by user ID
+ */
+export type UsersListUserIdUnion = string | UsersListUserId;
+
+/**
+ * Filter by first seen timestamp (e.g., first_seen[gte]=2024-01-01T00:00:00Z)
+ */
+export type FirstSeen = {
+  gte?: Date | undefined;
+  gt?: Date | undefined;
+  lte?: Date | undefined;
+  lt?: Date | undefined;
+};
+
+/**
+ * Filter by last seen timestamp
+ */
+export type LastSeen = {
+  gte?: Date | undefined;
+  gt?: Date | undefined;
+  lte?: Date | undefined;
+  lt?: Date | undefined;
+};
+
+export type UsersListEq = string | number | boolean;
+
+export type UsersListNeq = string | number | boolean;
+
+export type UsersListTraits = {
+  eq?: string | number | boolean | undefined;
+  neq?: string | number | boolean | undefined;
+  gt?: number | undefined;
+  gte?: number | undefined;
+  lt?: number | undefined;
+  lte?: number | undefined;
+};
+
+export type UsersListTraitsUnion = string | number | boolean | UsersListTraits;
+
+export type UsersListRequest = {
+  limit?: number | undefined;
+  cursor?: string | undefined;
+  orderBy?: string | undefined;
+  /**
+   * Filter by user ID
+   */
+  userId?: string | UsersListUserId | undefined;
+  /**
+   * Filter by first seen timestamp (e.g., first_seen[gte]=2024-01-01T00:00:00Z)
+   */
+  firstSeen?: FirstSeen | undefined;
+  /**
+   * Filter by last seen timestamp
+   */
+  lastSeen?: LastSeen | undefined;
+  traits?:
+    | { [k: string]: string | number | boolean | UsersListTraits }
+    | undefined;
+};
+
+export type UsersListDetails = {
+  field?: string | undefined;
+  allowedFields?: Array<string> | undefined;
+};
+
+export type UsersListError = {
+  /**
+   * Error code
+   */
+  code: string;
+  /**
+   * Human-readable error message
+   */
+  message: string;
+  details?: UsersListDetails | undefined;
+};
+
+export type UsersListData = {
+  id: string;
+  traits: { [k: string]: any | null } | null;
+  firstSeen: Date;
+  lastSeen: Date;
+  eventCount?: number | undefined;
+};
+
+export type UsersListMeta = {
+  /**
+   * Cursor for next page
+   */
+  cursor: string | null;
+  /**
+   * Whether there are more results
+   */
+  hasMore: boolean;
+};
+
+/**
+ * List of users
+ */
+export type UsersListResponse = {
+  /**
+   * List of items
+   */
+  data: Array<UsersListData>;
+  meta: UsersListMeta;
+};
+
+/** @internal */
+export type UsersListUserId$Outbound = {
+  eq?: string | undefined;
+  neq?: string | undefined;
+  startsWith?: string | undefined;
+  endsWith?: string | undefined;
+  contains?: string | undefined;
+};
+
+/** @internal */
+export const UsersListUserId$outboundSchema: z.ZodMiniType<
+  UsersListUserId$Outbound,
+  UsersListUserId
+> = z.object({
+  eq: z.optional(z.string()),
+  neq: z.optional(z.string()),
+  startsWith: z.optional(z.string()),
+  endsWith: z.optional(z.string()),
+  contains: z.optional(z.string()),
+});
+
+export function usersListUserIdToJSON(
+  usersListUserId: UsersListUserId,
+): string {
+  return JSON.stringify(UsersListUserId$outboundSchema.parse(usersListUserId));
+}
+
+/** @internal */
+export type UsersListUserIdUnion$Outbound = string | UsersListUserId$Outbound;
+
+/** @internal */
+export const UsersListUserIdUnion$outboundSchema: z.ZodMiniType<
+  UsersListUserIdUnion$Outbound,
+  UsersListUserIdUnion
+> = smartUnion([z.string(), z.lazy(() => UsersListUserId$outboundSchema)]);
+
+export function usersListUserIdUnionToJSON(
+  usersListUserIdUnion: UsersListUserIdUnion,
+): string {
+  return JSON.stringify(
+    UsersListUserIdUnion$outboundSchema.parse(usersListUserIdUnion),
+  );
+}
+
+/** @internal */
+export type FirstSeen$Outbound = {
+  gte?: string | undefined;
+  gt?: string | undefined;
+  lte?: string | undefined;
+  lt?: string | undefined;
+};
+
+/** @internal */
+export const FirstSeen$outboundSchema: z.ZodMiniType<
+  FirstSeen$Outbound,
+  FirstSeen
+> = z.object({
+  gte: z.optional(z.pipe(z.date(), z.transform(v => v.toISOString()))),
+  gt: z.optional(z.pipe(z.date(), z.transform(v => v.toISOString()))),
+  lte: z.optional(z.pipe(z.date(), z.transform(v => v.toISOString()))),
+  lt: z.optional(z.pipe(z.date(), z.transform(v => v.toISOString()))),
+});
+
+export function firstSeenToJSON(firstSeen: FirstSeen): string {
+  return JSON.stringify(FirstSeen$outboundSchema.parse(firstSeen));
+}
+
+/** @internal */
+export type LastSeen$Outbound = {
+  gte?: string | undefined;
+  gt?: string | undefined;
+  lte?: string | undefined;
+  lt?: string | undefined;
+};
+
+/** @internal */
+export const LastSeen$outboundSchema: z.ZodMiniType<
+  LastSeen$Outbound,
+  LastSeen
+> = z.object({
+  gte: z.optional(z.pipe(z.date(), z.transform(v => v.toISOString()))),
+  gt: z.optional(z.pipe(z.date(), z.transform(v => v.toISOString()))),
+  lte: z.optional(z.pipe(z.date(), z.transform(v => v.toISOString()))),
+  lt: z.optional(z.pipe(z.date(), z.transform(v => v.toISOString()))),
+});
+
+export function lastSeenToJSON(lastSeen: LastSeen): string {
+  return JSON.stringify(LastSeen$outboundSchema.parse(lastSeen));
+}
+
+/** @internal */
+export type UsersListEq$Outbound = string | number | boolean;
+
+/** @internal */
+export const UsersListEq$outboundSchema: z.ZodMiniType<
+  UsersListEq$Outbound,
+  UsersListEq
+> = smartUnion([z.string(), z.number(), z.boolean()]);
+
+export function usersListEqToJSON(usersListEq: UsersListEq): string {
+  return JSON.stringify(UsersListEq$outboundSchema.parse(usersListEq));
+}
+
+/** @internal */
+export type UsersListNeq$Outbound = string | number | boolean;
+
+/** @internal */
+export const UsersListNeq$outboundSchema: z.ZodMiniType<
+  UsersListNeq$Outbound,
+  UsersListNeq
+> = smartUnion([z.string(), z.number(), z.boolean()]);
+
+export function usersListNeqToJSON(usersListNeq: UsersListNeq): string {
+  return JSON.stringify(UsersListNeq$outboundSchema.parse(usersListNeq));
+}
+
+/** @internal */
+export type UsersListTraits$Outbound = {
+  eq?: string | number | boolean | undefined;
+  neq?: string | number | boolean | undefined;
+  gt?: number | undefined;
+  gte?: number | undefined;
+  lt?: number | undefined;
+  lte?: number | undefined;
+};
+
+/** @internal */
+export const UsersListTraits$outboundSchema: z.ZodMiniType<
+  UsersListTraits$Outbound,
+  UsersListTraits
+> = z.object({
+  eq: z.optional(smartUnion([z.string(), z.number(), z.boolean()])),
+  neq: z.optional(smartUnion([z.string(), z.number(), z.boolean()])),
+  gt: z.optional(z.number()),
+  gte: z.optional(z.number()),
+  lt: z.optional(z.number()),
+  lte: z.optional(z.number()),
+});
+
+export function usersListTraitsToJSON(
+  usersListTraits: UsersListTraits,
+): string {
+  return JSON.stringify(UsersListTraits$outboundSchema.parse(usersListTraits));
+}
+
+/** @internal */
+export type UsersListTraitsUnion$Outbound =
+  | string
+  | number
+  | boolean
+  | UsersListTraits$Outbound;
+
+/** @internal */
+export const UsersListTraitsUnion$outboundSchema: z.ZodMiniType<
+  UsersListTraitsUnion$Outbound,
+  UsersListTraitsUnion
+> = smartUnion([
+  z.string(),
+  z.number(),
+  z.boolean(),
+  z.lazy(() => UsersListTraits$outboundSchema),
+]);
+
+export function usersListTraitsUnionToJSON(
+  usersListTraitsUnion: UsersListTraitsUnion,
+): string {
+  return JSON.stringify(
+    UsersListTraitsUnion$outboundSchema.parse(usersListTraitsUnion),
+  );
+}
+
+/** @internal */
+export type UsersListRequest$Outbound = {
+  limit: number;
+  cursor?: string | undefined;
+  order_by: string;
+  user_id?: string | UsersListUserId$Outbound | undefined;
+  first_seen?: FirstSeen$Outbound | undefined;
+  last_seen?: LastSeen$Outbound | undefined;
+  traits?:
+    | { [k: string]: string | number | boolean | UsersListTraits$Outbound }
+    | undefined;
+};
+
+/** @internal */
+export const UsersListRequest$outboundSchema: z.ZodMiniType<
+  UsersListRequest$Outbound,
+  UsersListRequest
+> = z.pipe(
+  z.object({
+    limit: z._default(z.number(), 50),
+    cursor: z.optional(z.string()),
+    orderBy: z._default(z.string(), "-timestamp"),
+    userId: z.optional(
+      smartUnion([z.string(), z.lazy(() => UsersListUserId$outboundSchema)]),
+    ),
+    firstSeen: z.optional(z.lazy(() => FirstSeen$outboundSchema)),
+    lastSeen: z.optional(z.lazy(() => LastSeen$outboundSchema)),
+    traits: z.optional(
+      z.record(
+        z.string(),
+        smartUnion([
+          z.string(),
+          z.number(),
+          z.boolean(),
+          z.lazy(() => UsersListTraits$outboundSchema),
+        ]),
+      ),
+    ),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      orderBy: "order_by",
+      userId: "user_id",
+      firstSeen: "first_seen",
+      lastSeen: "last_seen",
+    });
+  }),
+);
+
+export function usersListRequestToJSON(
+  usersListRequest: UsersListRequest,
+): string {
+  return JSON.stringify(
+    UsersListRequest$outboundSchema.parse(usersListRequest),
+  );
+}
+
+/** @internal */
+export const UsersListDetails$inboundSchema: z.ZodMiniType<
+  UsersListDetails,
+  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 usersListDetailsFromJSON(
+  jsonString: string,
+): SafeParseResult<UsersListDetails, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UsersListDetails$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UsersListDetails' from JSON`,
+  );
+}
+
+/** @internal */
+export const UsersListError$inboundSchema: z.ZodMiniType<
+  UsersListError,
+  unknown
+> = z.object({
+  code: types.string(),
+  message: types.string(),
+  details: types.optional(z.lazy(() => UsersListDetails$inboundSchema)),
+});
+
+export function usersListErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<UsersListError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UsersListError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UsersListError' from JSON`,
+  );
+}
+
+/** @internal */
+export const UsersListData$inboundSchema: z.ZodMiniType<
+  UsersListData,
+  unknown
+> = z.pipe(
+  z.object({
+    id: types.string(),
+    traits: types.nullable(z.record(z.string(), types.nullable(z.any()))),
+    first_seen: types.date(),
+    last_seen: types.date(),
+    event_count: types.optional(types.number()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "first_seen": "firstSeen",
+      "last_seen": "lastSeen",
+      "event_count": "eventCount",
+    });
+  }),
+);
+
+export function usersListDataFromJSON(
+  jsonString: string,
+): SafeParseResult<UsersListData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UsersListData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UsersListData' from JSON`,
+  );
+}
+
+/** @internal */
+export const UsersListMeta$inboundSchema: z.ZodMiniType<
+  UsersListMeta,
+  unknown
+> = z.pipe(
+  z.object({
+    cursor: types.nullable(types.string()),
+    has_more: types.boolean(),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "has_more": "hasMore",
+    });
+  }),
+);
+
+export function usersListMetaFromJSON(
+  jsonString: string,
+): SafeParseResult<UsersListMeta, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UsersListMeta$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UsersListMeta' from JSON`,
+  );
+}
+
+/** @internal */
+export const UsersListResponse$inboundSchema: z.ZodMiniType<
+  UsersListResponse,
+  unknown
+> = z.object({
+  data: z.array(z.lazy(() => UsersListData$inboundSchema)),
+  meta: z.lazy(() => UsersListMeta$inboundSchema),
+});
+
+export function usersListResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<UsersListResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UsersListResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UsersListResponse' from JSON`,
+  );
+}

package/src/models/security.ts

@@ -0,0 +1,26 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+export type Security = {
+  apiKey: string;
+};
+
+/** @internal */
+export type Security$Outbound = {
+  apiKey: string;
+};
+
+/** @internal */
+export const Security$outboundSchema: z.ZodMiniType<
+  Security$Outbound,
+  Security
+> = z.object({
+  apiKey: z.string(),
+});
+
+export function securityToJSON(security: Security): string {
+  return JSON.stringify(Security$outboundSchema.parse(security));
+}

package/src/sdk/conversations.ts

@@ -0,0 +1,45 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { conversationsGet } from "../funcs/conversations-get.js";
+import { conversationsList } from "../funcs/conversations-list.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Conversations extends ClientSDK {
+  /**
+   * List conversations
+   *
+   * @remarks
+   * Retrieve a paginated list of conversations
+   */
+  async list(
+    request?: operations.ConversationsListRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.ConversationsListResponse> {
+    return unwrapAsync(conversationsList(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get conversation details
+   *
+   * @remarks
+   * Retrieve details of a specific conversation
+   */
+  async get(
+    request: operations.ConversationsGetRequest,
+    options?: RequestOptions,
+  ): Promise<operations.ConversationsGetResponse> {
+    return unwrapAsync(conversationsGet(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/events.ts

@@ -0,0 +1,117 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { eventsCount } from "../funcs/events-count.js";
+import { eventsFacets } from "../funcs/events-facets.js";
+import { eventsGet } from "../funcs/events-get.js";
+import { eventsList } from "../funcs/events-list.js";
+import { eventsSearch } from "../funcs/events-search.js";
+import { eventsTimeseries } from "../funcs/events-timeseries.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Events extends ClientSDK {
+  /**
+   * List events
+   *
+   * @remarks
+   * Retrieve a paginated list of events with optional filters
+   */
+  async list(
+    request?: operations.EventsListRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.EventsListResponse> {
+    return unwrapAsync(eventsList(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Search events (GET)
+   *
+   * @remarks
+   * Search for events using text, semantic, or regex matching. Date range limited to 14 days.
+   */
+  async search(
+    request: operations.EventsSearchRequest,
+    options?: RequestOptions,
+  ): Promise<operations.EventsSearchResponse> {
+    return unwrapAsync(eventsSearch(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Count events
+   *
+   * @remarks
+   * Count events matching optional filters
+   */
+  async count(
+    request?: operations.EventsCountRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.EventsCountResponse> {
+    return unwrapAsync(eventsCount(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get event timeseries
+   *
+   * @remarks
+   * Get time-bucketed event counts
+   */
+  async timeseries(
+    request?: operations.EventsTimeseriesRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.EventsTimeseriesResponse> {
+    return unwrapAsync(eventsTimeseries(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get event facets
+   *
+   * @remarks
+   * Get distinct values and counts for a field (event_name, user_id, or signal)
+   */
+  async facets(
+    request?: operations.EventsFacetsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.EventsFacetsResponse> {
+    return unwrapAsync(eventsFacets(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get event details
+   *
+   * @remarks
+   * Retrieve details of a specific event
+   */
+  async get(
+    request: operations.EventsGetRequest,
+    options?: RequestOptions,
+  ): Promise<operations.EventsGetResponse> {
+    return unwrapAsync(eventsGet(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/index.ts

@@ -0,0 +1,5 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+export * from "./sdk.js";

package/src/sdk/sdk.ts

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { ClientSDK } from "../lib/sdks.js";
+import { Conversations } from "./conversations.js";
+import { Events } from "./events.js";
+import { SignalGroups } from "./signal-groups.js";
+import { Signals } from "./signals.js";
+import { Users } from "./users.js";
+
+export class RaindropQuery extends ClientSDK {
+  private _signals?: Signals;
+  get signals(): Signals {
+    return (this._signals ??= new Signals(this._options));
+  }
+
+  private _signalGroups?: SignalGroups;
+  get signalGroups(): SignalGroups {
+    return (this._signalGroups ??= new SignalGroups(this._options));
+  }
+
+  private _events?: Events;
+  get events(): Events {
+    return (this._events ??= new Events(this._options));
+  }
+
+  private _users?: Users;
+  get users(): Users {
+    return (this._users ??= new Users(this._options));
+  }
+
+  private _conversations?: Conversations;
+  get conversations(): Conversations {
+    return (this._conversations ??= new Conversations(this._options));
+  }
+}