@hookdeck/outpost-sdk 0.2.0 → 0.4.0

package/src/models/operations/listtenanteventsbydestination.ts

@@ -7,6 +7,7 @@ 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 components from "../components/index.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type ListTenantEventsByDestinationGlobals = {
@@ -40,6 +41,49 @@ export type ListTenantEventsByDestinationRequest = {
    * Filter events by delivery status.
    */
   status?: ListTenantEventsByDestinationStatus | undefined;
+  /**
+   * Cursor for next page of results
+   */
+  next?: string | undefined;
+  /**
+   * Cursor for previous page of results
+   */
+  prev?: string | undefined;
+  /**
+   * Number of items per page (default 100, max 1000)
+   */
+  limit?: number | undefined;
+  /**
+   * Start time filter (RFC3339 format)
+   */
+  start?: Date | undefined;
+  /**
+   * End time filter (RFC3339 format)
+   */
+  end?: Date | undefined;
+};
+
+/**
+ * A paginated list of events for the destination.
+ */
+export type ListTenantEventsByDestinationResponseBody = {
+  /**
+   * Total number of items across all pages
+   */
+  count: number;
+  data: Array<components.Event>;
+  /**
+   * Cursor for next page (empty string if no next page)
+   */
+  nextCursor: string;
+  /**
+   * Cursor for previous page (empty string if no previous page)
+   */
+  prevCursor: string;
+};
+
+export type ListTenantEventsByDestinationResponse = {
+  result: ListTenantEventsByDestinationResponseBody;
 };
 
 /** @internal */
@@ -141,6 +185,13 @@ export const ListTenantEventsByDestinationRequest$inboundSchema: z.ZodType<
   tenant_id: z.string().optional(),
   destination_id: z.string(),
   status: ListTenantEventsByDestinationStatus$inboundSchema.optional(),
+  next: z.string().optional(),
+  prev: z.string().optional(),
+  limit: z.number().int().default(100),
+  start: z.string().datetime({ offset: true }).transform(v => new Date(v))
+    .optional(),
+  end: z.string().datetime({ offset: true }).transform(v => new Date(v))
+    .optional(),
 }).transform((v) => {
   return remap$(v, {
     "tenant_id": "tenantId",
@@ -153,6 +204,11 @@ export type ListTenantEventsByDestinationRequest$Outbound = {
   tenant_id?: string | undefined;
   destination_id: string;
   status?: string | undefined;
+  next?: string | undefined;
+  prev?: string | undefined;
+  limit: number;
+  start?: string | undefined;
+  end?: string | undefined;
 };
 
 /** @internal */
@@ -164,6 +220,11 @@ export const ListTenantEventsByDestinationRequest$outboundSchema: z.ZodType<
   tenantId: z.string().optional(),
   destinationId: z.string(),
   status: ListTenantEventsByDestinationStatus$outboundSchema.optional(),
+  next: z.string().optional(),
+  prev: z.string().optional(),
+  limit: z.number().int().default(100),
+  start: z.date().transform(v => v.toISOString()).optional(),
+  end: z.date().transform(v => v.toISOString()).optional(),
 }).transform((v) => {
   return remap$(v, {
     tenantId: "tenant_id",
@@ -206,3 +267,157 @@ export function listTenantEventsByDestinationRequestFromJSON(
     `Failed to parse 'ListTenantEventsByDestinationRequest' from JSON`,
   );
 }
+
+/** @internal */
+export const ListTenantEventsByDestinationResponseBody$inboundSchema: z.ZodType<
+  ListTenantEventsByDestinationResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  count: z.number().int(),
+  data: z.array(components.Event$inboundSchema),
+  next: z.string(),
+  prev: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "next": "nextCursor",
+    "prev": "prevCursor",
+  });
+});
+
+/** @internal */
+export type ListTenantEventsByDestinationResponseBody$Outbound = {
+  count: number;
+  data: Array<components.Event$Outbound>;
+  next: string;
+  prev: string;
+};
+
+/** @internal */
+export const ListTenantEventsByDestinationResponseBody$outboundSchema:
+  z.ZodType<
+    ListTenantEventsByDestinationResponseBody$Outbound,
+    z.ZodTypeDef,
+    ListTenantEventsByDestinationResponseBody
+  > = z.object({
+    count: z.number().int(),
+    data: z.array(components.Event$outboundSchema),
+    nextCursor: z.string(),
+    prevCursor: z.string(),
+  }).transform((v) => {
+    return remap$(v, {
+      nextCursor: "next",
+      prevCursor: "prev",
+    });
+  });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ListTenantEventsByDestinationResponseBody$ {
+  /** @deprecated use `ListTenantEventsByDestinationResponseBody$inboundSchema` instead. */
+  export const inboundSchema =
+    ListTenantEventsByDestinationResponseBody$inboundSchema;
+  /** @deprecated use `ListTenantEventsByDestinationResponseBody$outboundSchema` instead. */
+  export const outboundSchema =
+    ListTenantEventsByDestinationResponseBody$outboundSchema;
+  /** @deprecated use `ListTenantEventsByDestinationResponseBody$Outbound` instead. */
+  export type Outbound = ListTenantEventsByDestinationResponseBody$Outbound;
+}
+
+export function listTenantEventsByDestinationResponseBodyToJSON(
+  listTenantEventsByDestinationResponseBody:
+    ListTenantEventsByDestinationResponseBody,
+): string {
+  return JSON.stringify(
+    ListTenantEventsByDestinationResponseBody$outboundSchema.parse(
+      listTenantEventsByDestinationResponseBody,
+    ),
+  );
+}
+
+export function listTenantEventsByDestinationResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  ListTenantEventsByDestinationResponseBody,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ListTenantEventsByDestinationResponseBody$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'ListTenantEventsByDestinationResponseBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListTenantEventsByDestinationResponse$inboundSchema: z.ZodType<
+  ListTenantEventsByDestinationResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  Result: z.lazy(() => ListTenantEventsByDestinationResponseBody$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "Result": "result",
+  });
+});
+
+/** @internal */
+export type ListTenantEventsByDestinationResponse$Outbound = {
+  Result: ListTenantEventsByDestinationResponseBody$Outbound;
+};
+
+/** @internal */
+export const ListTenantEventsByDestinationResponse$outboundSchema: z.ZodType<
+  ListTenantEventsByDestinationResponse$Outbound,
+  z.ZodTypeDef,
+  ListTenantEventsByDestinationResponse
+> = z.object({
+  result: z.lazy(() =>
+    ListTenantEventsByDestinationResponseBody$outboundSchema
+  ),
+}).transform((v) => {
+  return remap$(v, {
+    result: "Result",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ListTenantEventsByDestinationResponse$ {
+  /** @deprecated use `ListTenantEventsByDestinationResponse$inboundSchema` instead. */
+  export const inboundSchema =
+    ListTenantEventsByDestinationResponse$inboundSchema;
+  /** @deprecated use `ListTenantEventsByDestinationResponse$outboundSchema` instead. */
+  export const outboundSchema =
+    ListTenantEventsByDestinationResponse$outboundSchema;
+  /** @deprecated use `ListTenantEventsByDestinationResponse$Outbound` instead. */
+  export type Outbound = ListTenantEventsByDestinationResponse$Outbound;
+}
+
+export function listTenantEventsByDestinationResponseToJSON(
+  listTenantEventsByDestinationResponse: ListTenantEventsByDestinationResponse,
+): string {
+  return JSON.stringify(
+    ListTenantEventsByDestinationResponse$outboundSchema.parse(
+      listTenantEventsByDestinationResponse,
+    ),
+  );
+}
+
+export function listTenantEventsByDestinationResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ListTenantEventsByDestinationResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ListTenantEventsByDestinationResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListTenantEventsByDestinationResponse' from JSON`,
+  );
+}

package/src/sdk/events.ts

@@ -12,6 +12,7 @@ import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as components from "../models/components/index.js";
 import * as operations from "../models/operations/index.js";
 import { unwrapAsync } from "../types/fp.js";
+import { PageIterator, unwrapResultIterator } from "../types/operations.js";
 
 export class Events extends ClientSDK {
   /**
@@ -23,8 +24,10 @@ export class Events extends ClientSDK {
   async list(
     request: operations.ListTenantEventsRequest,
     options?: RequestOptions,
-  ): Promise<Array<components.Event>> {
-    return unwrapAsync(eventsList(
+  ): Promise<
+    PageIterator<operations.ListTenantEventsResponse, { cursor: string }>
+  > {
+    return unwrapResultIterator(eventsList(
       this,
       request,
       options,
@@ -74,8 +77,13 @@ export class Events extends ClientSDK {
   async listByDestination(
     request: operations.ListTenantEventsByDestinationRequest,
     options?: RequestOptions,
-  ): Promise<Array<components.Event>> {
-    return unwrapAsync(eventsListByDestination(
+  ): Promise<
+    PageIterator<
+      operations.ListTenantEventsByDestinationResponse,
+      { cursor: string }
+    >
+  > {
+    return unwrapResultIterator(eventsListByDestination(
       this,
       request,
       options,

package/src/sdk/publish.ts

@@ -17,7 +17,7 @@ export class Publish extends ClientSDK {
   async event(
     request: components.PublishRequest,
     options?: RequestOptions,
-  ): Promise<void> {
+  ): Promise<components.PublishResponse> {
     return unwrapAsync(publishEvent(
       this,
       request,

package/src/types/constdatetime.ts

@@ -11,5 +11,5 @@ export function constDateTime(
     return (
       typeof v === "string" && new Date(v).getTime() === new Date(val).getTime()
     );
-  }, `Value must be equivelant to ${val}`);
+  }, `Value must be equivalent to ${val}`);
 }