@jphil/bookwhen-client 0.4.2 → 0.5.1

package/dist/index.d.ts

@@ -1,6 +1,51 @@
 import { AxiosInstance } from 'axios';
 import { z } from 'zod';
 
+declare interface AttachmentAttributes {
+    title: string;
+    file_url: string;
+    file_size_bytes: string;
+    file_size_text: string;
+    file_name: string;
+    file_type: string;
+    content_type: string;
+}
+
+export declare type AttachmentFilters = {
+    [K in keyof AttachmentFiltersMap]?: AttachmentFiltersMap[K];
+};
+
+declare interface AttachmentFiltersMap {
+    title?: string;
+    file_name?: string;
+    file_type?: string;
+}
+
+declare interface AttachmentResponse extends JsonApiResponse_4<BookwhenAttachment> {
+}
+
+declare class AttachmentService implements IAttachmentService {
+    private axiosInstance;
+    constructor(axiosInstance: AxiosInstance);
+    getById(params: z.infer<typeof GetAttachmentByIdParamsSchema>): Promise<AttachmentResponse>;
+    getMultiple(params?: GetMultipleAttachmentsParams): Promise<AttachmentsResponse>;
+}
+
+declare interface AttachmentsResponse extends JsonApiResponse_4<BookwhenAttachment[]> {
+}
+
+declare interface BookwhenAttachment {
+    id: string;
+    type: string;
+    attributes: AttachmentAttributes;
+}
+
+declare interface BookwhenClassPass {
+    id: string;
+    type: string;
+    attributes: ClassPassAttributes;
+}
+
 /**
  * Client for the Bookwhen API.
  *
@@ -9,6 +54,10 @@ import { z } from 'zod';
 declare class BookwhenClient {
     private axiosInstance;
     private eventService?;
+    private ticketService?;
+    private locationService?;
+    private attachmentService?;
+    private classPassService?;
     private readonly isBrowser;
     /**
      * Creates a new instance of the BookwhenClient class.
@@ -26,6 +75,10 @@ declare class BookwhenClient {
      * @returns The EventService instance.
      */
     get events(): EventService;
+    get tickets(): TicketService;
+    get locations(): LocationService;
+    get attachments(): AttachmentService;
+    get classPasses(): ClassPassService;
 }
 
 declare interface BookwhenClientOptions {
@@ -53,6 +106,54 @@ declare interface BookwhenEvent {
     attributes: EventAttributes;
 }
 
+declare interface BookwhenLocation {
+    id: string;
+    type: string;
+    attributes: LocationAttributes;
+}
+
+declare interface BookwhenTicket {
+    id: string;
+    type: string;
+    attributes: TicketAttributes;
+    relationships?: TicketRelationships;
+}
+
+declare interface ClassPassAttributes {
+    title: string;
+    details: string;
+    usage_allowance: number;
+    usage_type: 'personal' | 'any' | string;
+    number_available: number | null;
+    use_restricted_for_days: number | null;
+}
+
+declare interface ClassPassesResponse extends JsonApiResponse_5<BookwhenClassPass[]> {
+}
+
+export declare type ClassPassFilters = {
+    [K in keyof ClassPassFiltersMap]?: ClassPassFiltersMap[K];
+};
+
+declare interface ClassPassFiltersMap {
+    title?: string;
+    detail?: string;
+    usage_type?: 'personal' | 'any';
+    cost?: string;
+    usage_allowance?: string;
+    use_restricted_for_days?: string;
+}
+
+declare interface ClassPassResponse extends JsonApiResponse_5<BookwhenClassPass> {
+}
+
+declare class ClassPassService implements IClassPassService {
+    private axiosInstance;
+    constructor(axiosInstance: AxiosInstance);
+    getById(params: z.infer<typeof GetClassPassByIdParamsSchema>): Promise<ClassPassResponse>;
+    getMultiple(params?: GetMultipleClassPassesParams): Promise<ClassPassesResponse>;
+}
+
 /**
  * Creates an instance of Axios with the provided API key.
  * @param apiKey - The API key used for authentication.
@@ -143,6 +244,30 @@ export declare interface Filters {
     [key: string]: string | string[] | boolean;
 }
 
+export declare interface GetAttachmentByIdParams {
+    attachmentId: string;
+}
+
+declare const GetAttachmentByIdParamsSchema: z.ZodObject<{
+    attachmentId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    attachmentId: string;
+}, {
+    attachmentId: string;
+}>;
+
+export declare interface GetClassPassByIdParams {
+    classPassId: string;
+}
+
+declare const GetClassPassByIdParamsSchema: z.ZodObject<{
+    classPassId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    classPassId: string;
+}, {
+    classPassId: string;
+}>;
+
 /**
  * Parameters for querying a single event from the Bookwhen API, including optional include parameter.
  * @param eventId The unique identifier of the event.
@@ -164,6 +289,26 @@ declare const GetEventByIdParamsSchema: z.ZodObject<{
     includes?: ("location" | "attachments" | "tickets" | "tickets.events" | "tickets.class_passes")[] | undefined;
 }>;
 
+export declare interface GetLocationByIdParams {
+    locationId: string;
+}
+
+declare const GetLocationByIdParamsSchema: z.ZodObject<{
+    locationId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    locationId: string;
+}, {
+    locationId: string;
+}>;
+
+export declare interface GetMultipleAttachmentsParams {
+    filters?: AttachmentFilters;
+}
+
+export declare interface GetMultipleClassPassesParams {
+    filters?: ClassPassFilters;
+}
+
 /**
  * Represents the parameters for getting multiple events.
  * @param filter The filter parameters to apply to the query.
@@ -174,11 +319,46 @@ export declare interface GetMultipleEventsParams {
     includes?: EventResource[];
 }
 
+export declare interface GetMultipleLocationsParams {
+    filters?: LocationFilters;
+}
+
+export declare interface GetMultipleTicketsParams {
+    eventId: string;
+    includes?: TicketResource[];
+}
+
+export declare interface GetTicketByIdParams {
+    ticketId: string;
+    includes?: TicketResource[];
+}
+
+declare const GetTicketByIdParamsSchema: z.ZodObject<{
+    ticketId: z.ZodString;
+    includes: z.ZodOptional<z.ZodArray<z.ZodEnum<["class_passes", "events", "events.location", "events.tickets", "events.attachments"]>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    ticketId: string;
+    includes?: ("class_passes" | "events" | "events.location" | "events.tickets" | "events.attachments")[] | undefined;
+}, {
+    ticketId: string;
+    includes?: ("class_passes" | "events" | "events.location" | "events.tickets" | "events.attachments")[] | undefined;
+}>;
+
 export declare interface HttpStatus {
     code: number;
     message: string;
 }
 
+export declare interface IAttachmentService {
+    getById(params: GetAttachmentByIdParams): Promise<AttachmentResponse>;
+    getMultiple(params?: GetMultipleAttachmentsParams): Promise<AttachmentsResponse>;
+}
+
+export declare interface IClassPassService {
+    getById(params: GetClassPassByIdParams): Promise<ClassPassResponse>;
+    getMultiple(params?: GetMultipleClassPassesParams): Promise<ClassPassesResponse>;
+}
+
 /**
  * Interface for services handling events via the Bookwhen API V2.
  */
@@ -198,6 +378,16 @@ export declare interface IEventService {
     getMultiple?(params?: GetMultipleEventsParams): Promise<EventsResponse>;
 }
 
+export declare interface ILocationService {
+    getById(params: GetLocationByIdParams): Promise<LocationResponse>;
+    getMultiple(params?: GetMultipleLocationsParams): Promise<LocationsResponse>;
+}
+
+export declare interface ITicketService {
+    getById(params: GetTicketByIdParams): Promise<TicketResponse>;
+    getMultiple(params: GetMultipleTicketsParams): Promise<TicketsResponse>;
+}
+
 declare interface JsonApiResponse<T> {
     data: T;
     included?: any[];
@@ -217,6 +407,113 @@ declare interface JsonApiResponse<T> {
     };
 }
 
+declare interface JsonApiResponse_2<T> {
+    data: T;
+    included?: any[];
+    links?: {
+        self?: string;
+        first?: string;
+        last?: string;
+        prev?: string;
+        next?: string;
+    };
+    meta?: {
+        page?: {
+            current?: number;
+            total?: number;
+            size?: number;
+        };
+    };
+}
+
+declare interface JsonApiResponse_3<T> {
+    data: T;
+    included?: any[];
+    links?: {
+        self?: string;
+        first?: string;
+        last?: string;
+        prev?: string;
+        next?: string;
+    };
+    meta?: {
+        page?: {
+            current?: number;
+            total?: number;
+            size?: number;
+        };
+    };
+}
+
+declare interface JsonApiResponse_4<T> {
+    data: T;
+    included?: any[];
+    links?: {
+        self?: string;
+        first?: string;
+        last?: string;
+        prev?: string;
+        next?: string;
+    };
+    meta?: {
+        page?: {
+            current?: number;
+            total?: number;
+            size?: number;
+        };
+    };
+}
+
+declare interface JsonApiResponse_5<T> {
+    data: T;
+    included?: any[];
+    links?: {
+        self?: string;
+        first?: string;
+        last?: string;
+        prev?: string;
+        next?: string;
+    };
+    meta?: {
+        page?: {
+            current?: number;
+            total?: number;
+            size?: number;
+        };
+    };
+}
+
+declare interface LocationAttributes {
+    address_text: string;
+    additional_info: string;
+    latitude: number;
+    longitude: number;
+    zoom: number;
+    map_url: string;
+}
+
+export declare type LocationFilters = {
+    [K in keyof LocationFiltersMap]?: LocationFiltersMap[K];
+};
+
+declare interface LocationFiltersMap {
+    address_text?: string;
+    additional_info?: string;
+}
+
+declare interface LocationResponse extends JsonApiResponse_3<BookwhenLocation> {
+}
+
+declare class LocationService implements ILocationService {
+    private axiosInstance;
+    constructor(axiosInstance: AxiosInstance);
+    getById(params: z.infer<typeof GetLocationByIdParamsSchema>): Promise<LocationResponse>;
+    getMultiple(params?: GetMultipleLocationsParams): Promise<LocationsResponse>;
+}
+
+declare interface LocationsResponse extends JsonApiResponse_3<BookwhenLocation[]> {
+}
+
 /**
  * Generic JSON:API relationship resolver utility
  *
@@ -249,4 +546,57 @@ export declare type Resource = string;
 
 export declare type Resources = Resource[];
 
+declare interface TicketAttributes {
+    title: string;
+    details: string;
+    number_issued: number | null;
+    number_taken: number;
+    course_ticket: boolean;
+    group_ticket: boolean;
+    group_min: number | null;
+    group_max: number | null;
+    available: boolean;
+    available_from: string | null;
+    available_to: string | null;
+    cost: TicketCost;
+    built_basket_iframe_url: string;
+    built_basket_url: string;
+}
+
+declare interface TicketCost {
+    currency_code: string;
+    net: number;
+    tax: number;
+    face_value_net?: number;
+}
+
+declare interface TicketRelationshipData {
+    id: string;
+    type: string;
+}
+
+declare interface TicketRelationships {
+    events?: {
+        data: TicketRelationshipData[];
+    };
+    class_passes?: {
+        data: TicketRelationshipData[];
+    };
+}
+
+export declare type TicketResource = 'class_passes' | 'events' | 'events.location' | 'events.tickets' | 'events.attachments';
+
+declare interface TicketResponse extends JsonApiResponse_2<BookwhenTicket> {
+}
+
+declare class TicketService implements ITicketService {
+    private axiosInstance;
+    constructor(axiosInstance: AxiosInstance);
+    getById(params: z.infer<typeof GetTicketByIdParamsSchema>): Promise<TicketResponse>;
+    getMultiple(params: GetMultipleTicketsParams): Promise<TicketsResponse>;
+}
+
+declare interface TicketsResponse extends JsonApiResponse_2<BookwhenTicket[]> {
+}
+
 export { }

package/dist/index.js

@@ -6498,6 +6498,214 @@ class EventService {
     }
   }
 }
+const TicketResourceSchema = z.enum([
+  "class_passes",
+  "events",
+  "events.location",
+  "events.tickets",
+  "events.attachments"
+]);
+const GetTicketByIdParamsSchema = z.object({
+  ticketId: z.string().min(1, "Invalid ticket ID"),
+  includes: TicketResourceSchema.array().optional()
+});
+const GetMultipleTicketsParamsSchema = z.object({
+  eventId: z.string().min(1, "Invalid event ID"),
+  includes: TicketResourceSchema.array().optional()
+});
+class TicketService {
+  constructor(axiosInstance) {
+    __publicField(this, "axiosInstance");
+    this.axiosInstance = axiosInstance;
+  }
+  async getById(params) {
+    try {
+      const validParams = GetTicketByIdParamsSchema.parse(params);
+      const query = new BookwhenRequest(`/tickets/${validParams.ticketId}`);
+      if (validParams.includes) {
+        query.addIncludes(validParams.includes);
+      }
+      const response = await this.axiosInstance.get(`${query}`);
+      return response.data;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        const errorMessages = error.errors.map((e) => e.message).join(", ");
+        throw new Error(
+          `tickets.getById: Schema Validation failed: ${errorMessages}`
+        );
+      }
+      handleServiceHTTPErrors(error, SERVICE_HTTP_STATUS_CODES, {
+        404: {
+          code: 404,
+          message: "Ticket not found. Please check the ticket ID and try again."
+        }
+      });
+    }
+  }
+  async getMultiple(params) {
+    try {
+      const validParams = GetMultipleTicketsParamsSchema.parse(params);
+      const queryParts = [`event=${encodeURIComponent(validParams.eventId)}`];
+      if (validParams.includes?.length) {
+        queryParts.push(`include=${validParams.includes.join(",")}`);
+      }
+      const response = await this.axiosInstance.get(
+        `/tickets?${queryParts.join("&")}`
+      );
+      return response.data;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        const errorMessages = error.errors.map((e) => e.message).join(", ");
+        throw new Error(
+          `tickets.getMultiple: Schema Validation failed: ${errorMessages}`
+        );
+      }
+      handleServiceHTTPErrors(error, SERVICE_HTTP_STATUS_CODES);
+    }
+  }
+}
+const GetLocationByIdParamsSchema = z.object({
+  locationId: z.string().min(1, "Invalid location ID")
+});
+class LocationService {
+  constructor(axiosInstance) {
+    __publicField(this, "axiosInstance");
+    this.axiosInstance = axiosInstance;
+  }
+  async getById(params) {
+    try {
+      const validParams = GetLocationByIdParamsSchema.parse(params);
+      const query = new BookwhenRequest(`/locations/${validParams.locationId}`);
+      const response = await this.axiosInstance.get(
+        `${query}`
+      );
+      return response.data;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        const errorMessages = error.errors.map((e) => e.message).join(", ");
+        throw new Error(
+          `locations.getById: Schema Validation failed: ${errorMessages}`
+        );
+      }
+      handleServiceHTTPErrors(error, SERVICE_HTTP_STATUS_CODES, {
+        404: {
+          code: 404,
+          message: "Location not found. Please check the location ID and try again."
+        }
+      });
+    }
+  }
+  async getMultiple(params = {}) {
+    try {
+      const query = new BookwhenRequest("/locations");
+      if (params.filters) {
+        query.addFilters(params.filters);
+      }
+      const response = await this.axiosInstance.get(
+        `${query}`
+      );
+      return response.data;
+    } catch (error) {
+      handleServiceHTTPErrors(error, SERVICE_HTTP_STATUS_CODES);
+    }
+  }
+}
+const GetAttachmentByIdParamsSchema = z.object({
+  attachmentId: z.string().min(1, "Invalid attachment ID")
+});
+class AttachmentService {
+  constructor(axiosInstance) {
+    __publicField(this, "axiosInstance");
+    this.axiosInstance = axiosInstance;
+  }
+  async getById(params) {
+    try {
+      const validParams = GetAttachmentByIdParamsSchema.parse(params);
+      const query = new BookwhenRequest(
+        `/attachments/${validParams.attachmentId}`
+      );
+      const response = await this.axiosInstance.get(
+        `${query}`
+      );
+      return response.data;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        const errorMessages = error.errors.map((e) => e.message).join(", ");
+        throw new Error(
+          `attachments.getById: Schema Validation failed: ${errorMessages}`
+        );
+      }
+      handleServiceHTTPErrors(error, SERVICE_HTTP_STATUS_CODES, {
+        404: {
+          code: 404,
+          message: "Attachment not found. Please check the attachment ID and try again."
+        }
+      });
+    }
+  }
+  async getMultiple(params = {}) {
+    try {
+      const query = new BookwhenRequest("/attachments");
+      if (params.filters) {
+        query.addFilters(params.filters);
+      }
+      const response = await this.axiosInstance.get(
+        `${query}`
+      );
+      return response.data;
+    } catch (error) {
+      handleServiceHTTPErrors(error, SERVICE_HTTP_STATUS_CODES);
+    }
+  }
+}
+const GetClassPassByIdParamsSchema = z.object({
+  classPassId: z.string().min(1, "Invalid class pass ID")
+});
+class ClassPassService {
+  constructor(axiosInstance) {
+    __publicField(this, "axiosInstance");
+    this.axiosInstance = axiosInstance;
+  }
+  async getById(params) {
+    try {
+      const validParams = GetClassPassByIdParamsSchema.parse(params);
+      const query = new BookwhenRequest(
+        `/class_passes/${validParams.classPassId}`
+      );
+      const response = await this.axiosInstance.get(
+        `${query}`
+      );
+      return response.data;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        const errorMessages = error.errors.map((e) => e.message).join(", ");
+        throw new Error(
+          `classPasses.getById: Schema Validation failed: ${errorMessages}`
+        );
+      }
+      handleServiceHTTPErrors(error, SERVICE_HTTP_STATUS_CODES, {
+        404: {
+          code: 404,
+          message: "Class pass not found. Please check the class pass ID and try again."
+        }
+      });
+    }
+  }
+  async getMultiple(params = {}) {
+    try {
+      const query = new BookwhenRequest("/class_passes");
+      if (params.filters) {
+        query.addFilters(params.filters);
+      }
+      const response = await this.axiosInstance.get(
+        `${query}`
+      );
+      return response.data;
+    } catch (error) {
+      handleServiceHTTPErrors(error, SERVICE_HTTP_STATUS_CODES);
+    }
+  }
+}
 class BookwhenClient {
   /**
    * Creates a new instance of the BookwhenClient class.
@@ -6506,6 +6714,10 @@ class BookwhenClient {
    */
   constructor(axiosInstance) {
     __publicField(this, "eventService");
+    __publicField(this, "ticketService");
+    __publicField(this, "locationService");
+    __publicField(this, "attachmentService");
+    __publicField(this, "classPassService");
     __publicField(this, "isBrowser");
     this.axiosInstance = axiosInstance;
     this.isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
@@ -6528,6 +6740,30 @@ class BookwhenClient {
     }
     return this.eventService;
   }
+  get tickets() {
+    if (!this.ticketService) {
+      this.ticketService = new TicketService(this.axiosInstance);
+    }
+    return this.ticketService;
+  }
+  get locations() {
+    if (!this.locationService) {
+      this.locationService = new LocationService(this.axiosInstance);
+    }
+    return this.locationService;
+  }
+  get attachments() {
+    if (!this.attachmentService) {
+      this.attachmentService = new AttachmentService(this.axiosInstance);
+    }
+    return this.attachmentService;
+  }
+  get classPasses() {
+    if (!this.classPassService) {
+      this.classPassService = new ClassPassService(this.axiosInstance);
+    }
+    return this.classPassService;
+  }
 }
 function createBookwhenClient(options) {
   const {