@growsober/types 1.0.6 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@growsober/types",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Auto-generated TypeScript types from the GrowSober API OpenAPI specification",
   "main": "dist/index.js",
   "module": "dist/index.js",

package/src/generated.ts

@@ -2937,6 +2937,145 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/admin/gatherings/generate": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Generate ambient events from facilitator availability */
+        post: operations["AdminGatheringsController_generate"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/admin/gatherings/ambient": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get ambient events for a date range */
+        get: operations["AdminGatheringsController_getAmbientEvents"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/admin/gatherings/creators/{creatorId}/suggest": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Generate AI gathering type suggestions for a facilitator */
+        post: operations["AdminGatheringsController_suggestGatheringTypes"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/creators/{creatorId}/gathering-types": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get all gathering types for a creator */
+        get: operations["GatheringTypesController_findAll"];
+        put?: never;
+        /** Create a gathering type */
+        post: operations["GatheringTypesController_create"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/creators/{creatorId}/gathering-types/approved": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get approved gathering types for a creator */
+        get: operations["GatheringTypesController_findApproved"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/creators/{creatorId}/gathering-types/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get a gathering type by ID */
+        get: operations["GatheringTypesController_findOne"];
+        /** Update a gathering type */
+        put: operations["GatheringTypesController_update"];
+        post?: never;
+        /** Delete a gathering type */
+        delete: operations["GatheringTypesController_delete"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/creators/{creatorId}/gathering-types/{id}/approve": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /** Approve a gathering type */
+        put: operations["GatheringTypesController_approve"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/creators/{creatorId}/gathering-types/generate": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Generate AI suggestions for gathering types */
+        post: operations["GatheringTypesController_generateSuggestions"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/ambassadors/apply": {
         parameters: {
             query?: never;
@@ -7087,6 +7226,181 @@ export interface components {
             /** @description Total library content */
             totalContent: number;
         };
+        GenerateGatheringsDto: {
+            /** @description City ID to generate events for */
+            cityId: string;
+            /**
+             * @description Date to generate events for (YYYY-MM-DD)
+             * @example 2026-01-25
+             */
+            date: string;
+            /**
+             * @description Number of events to generate
+             * @default 10
+             * @example 10
+             */
+            count: number;
+        };
+        GeneratedEventDto: {
+            /** @description Event ID */
+            id: string;
+            /** @description Event title */
+            title: string;
+            /**
+             * Format: date-time
+             * @description Event start date
+             */
+            startDate: string;
+            /** @description Creator/facilitator name */
+            creatorName: string;
+            /** @description Venue name */
+            venueName?: string;
+        };
+        GenerateGatheringsResponseDto: {
+            /** @description List of generated events */
+            events: components["schemas"]["GeneratedEventDto"][];
+        };
+        AmbientEventDto: {
+            /** @description Event ID */
+            id: string;
+            /** @description Event title */
+            title: string;
+            /** @description Event description */
+            description?: Record<string, never>;
+            /**
+             * Format: date-time
+             * @description Event start date
+             */
+            startDate: string;
+            /** @description Event end date */
+            endDate?: Record<string, never>;
+            /** @description Creator info */
+            creator?: Record<string, never>;
+            /** @description Venue info */
+            venue?: Record<string, never>;
+        };
+        GetAmbientEventsResponseDto: {
+            /** @description List of ambient events */
+            events: components["schemas"]["AmbientEventDto"][];
+        };
+        GatheringTypeResponseDto: {
+            /** @description Gathering type ID */
+            id: string;
+            /** @description Creator/Facilitator ID */
+            creatorId: string;
+            /**
+             * @description Name of the gathering type
+             * @example Morning Yoga in the Park
+             */
+            name: string;
+            /** @description Description of the gathering */
+            description?: Record<string, never> | null;
+            /**
+             * @description Duration in minutes
+             * @example 60
+             */
+            duration: number;
+            /** @description Vibes/atmosphere tags */
+            vibes: string[];
+            /**
+             * @description Category
+             * @enum {string|null}
+             */
+            category?: "WALK" | "COFFEE" | "MOVEMENT" | "CONVERSATION" | "CREATIVE" | "COWORKING" | null;
+            /** @description Suggested price (null = free) */
+            suggestedPrice?: Record<string, never> | null;
+            /**
+             * @description Currency
+             * @example EUR
+             */
+            currency: string;
+            /** @description Whether AI generated this suggestion */
+            isAiGenerated: boolean;
+            /** @description Whether the facilitator approved this */
+            isApproved: boolean;
+            /** @description AI prompt context for debugging */
+            aiPromptContext?: Record<string, never> | null;
+            /** @description Default venue ID */
+            defaultVenueId?: Record<string, never> | null;
+            /** @description Default venue details */
+            defaultVenue?: Record<string, never> | null;
+            /**
+             * Format: date-time
+             * @description Created timestamp
+             */
+            createdAt: string;
+            /**
+             * Format: date-time
+             * @description Updated timestamp
+             */
+            updatedAt: string;
+        };
+        CreateGatheringTypeDto: {
+            /**
+             * @description Name of the gathering type
+             * @example Morning Yoga in the Park
+             */
+            name: string;
+            /** @description Description of the gathering */
+            description?: string;
+            /**
+             * @description Duration in minutes
+             * @default 60
+             * @example 60
+             */
+            duration: number;
+            /** @description Vibes/atmosphere tags */
+            vibes?: string[];
+            /**
+             * @description Category
+             * @enum {string}
+             */
+            category?: "WALK" | "COFFEE" | "MOVEMENT" | "CONVERSATION" | "CREATIVE" | "COWORKING";
+            /** @description Suggested price (null = free) */
+            suggestedPrice?: number;
+            /**
+             * @description Currency
+             * @default EUR
+             * @example EUR
+             */
+            currency: string;
+            /** @description Default venue ID */
+            defaultVenueId?: string;
+        };
+        UpdateGatheringTypeDto: {
+            /**
+             * @description Name of the gathering type
+             * @example Morning Yoga in the Park
+             */
+            name?: string;
+            /** @description Description of the gathering */
+            description?: string;
+            /**
+             * @description Duration in minutes
+             * @default 60
+             * @example 60
+             */
+            duration: number;
+            /** @description Vibes/atmosphere tags */
+            vibes?: string[];
+            /**
+             * @description Category
+             * @enum {string}
+             */
+            category?: "WALK" | "COFFEE" | "MOVEMENT" | "CONVERSATION" | "CREATIVE" | "COWORKING";
+            /** @description Suggested price (null = free) */
+            suggestedPrice?: number;
+            /**
+             * @description Currency
+             * @default EUR
+             * @example EUR
+             */
+            currency: string;
+            /** @description Default venue ID */
+            defaultVenueId?: string;
+            /** @description Whether the gathering type is approved */
+            isApproved?: boolean;
+        };
         ApplyAmbassadorDto: {
             /** @description Hub ID to apply for */
             hubId?: string;
@@ -14545,6 +14859,277 @@ export interface operations {
             };
         };
     };
+    AdminGatheringsController_generate: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["GenerateGatheringsDto"];
+            };
+        };
+        responses: {
+            /** @description Events generated */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GenerateGatheringsResponseDto"];
+                };
+            };
+        };
+    };
+    AdminGatheringsController_getAmbientEvents: {
+        parameters: {
+            query: {
+                /** @description City ID to filter by */
+                cityId: string;
+                /** @description Start date (YYYY-MM-DD) */
+                startDate: string;
+                /** @description End date (YYYY-MM-DD) */
+                endDate: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description List of ambient events */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GetAmbientEventsResponseDto"];
+                };
+            };
+        };
+    };
+    AdminGatheringsController_suggestGatheringTypes: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                creatorId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Suggestions generated */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GatheringTypeResponseDto"][];
+                };
+            };
+        };
+    };
+    GatheringTypesController_findAll: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Creator ID */
+                creatorId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description List of gathering types */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GatheringTypeResponseDto"][];
+                };
+            };
+        };
+    };
+    GatheringTypesController_create: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Creator ID */
+                creatorId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateGatheringTypeDto"];
+            };
+        };
+        responses: {
+            /** @description Gathering type created */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GatheringTypeResponseDto"];
+                };
+            };
+        };
+    };
+    GatheringTypesController_findApproved: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Creator ID */
+                creatorId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description List of approved gathering types */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GatheringTypeResponseDto"][];
+                };
+            };
+        };
+    };
+    GatheringTypesController_findOne: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Gathering type ID */
+                id: string;
+                /** @description Creator ID */
+                creatorId: unknown;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Gathering type details */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GatheringTypeResponseDto"];
+                };
+            };
+        };
+    };
+    GatheringTypesController_update: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Gathering type ID */
+                id: string;
+                /** @description Creator ID */
+                creatorId: unknown;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateGatheringTypeDto"];
+            };
+        };
+        responses: {
+            /** @description Gathering type updated */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GatheringTypeResponseDto"];
+                };
+            };
+        };
+    };
+    GatheringTypesController_delete: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Gathering type ID */
+                id: string;
+                /** @description Creator ID */
+                creatorId: unknown;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Gathering type deleted */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    GatheringTypesController_approve: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Gathering type ID */
+                id: string;
+                /** @description Creator ID */
+                creatorId: unknown;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Gathering type approved */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GatheringTypeResponseDto"];
+                };
+            };
+        };
+    };
+    GatheringTypesController_generateSuggestions: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Creator ID */
+                creatorId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Suggestions generated */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GatheringTypeResponseDto"][];
+                };
+            };
+        };
+    };
     AmbassadorsController_apply: {
         parameters: {
             query?: never;