@teardown/ingest-api 0.0.18 → 0.0.21-alpha.10

package/dist/client/client.d.ts

@@ -1,9 +1,143 @@
 import { edenFetch } from "@elysiajs/eden";
-import type { IngestApp } from "../types/app";
-export type ClientConfig = NonNullable<Parameters<typeof edenFetch<IngestApp>>[1]>;
-export declare const client: (server: string, config?: import("@elysiajs/eden/fetch").EdenFetch.Config) => import("@elysiajs/eden/fetch").EdenFetch.Fn<unknown>;
+import type { IngestApp } from "@teardown/ingest/types";
+export type ClientConfig = NonNullable<Parameters<typeof edenFetch<typeof IngestApp>>[1]>;
+export declare const client: (server: string, config?: import("@elysiajs/eden/fetch").EdenFetch.Config) => import("@elysiajs/eden/fetch").EdenFetch.Fn<{
+    "/health": {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: {
+                    status: string;
+                    timestamp: string;
+                };
+            };
+        };
+    };
+} & {
+    "/v1/identify": {
+        post: {
+            body: {
+                device: {
+                    application: {
+                        version: string;
+                        build_number: string;
+                    };
+                    update: {
+                        is_enabled: boolean;
+                        update_id: string;
+                        update_channel: string;
+                        runtime_version: string;
+                        emergency_launch: {
+                            is_emergency_launch: true;
+                            reason: string;
+                        } | {
+                            is_emergency_launch: false;
+                            reason?: undefined;
+                        };
+                        is_embedded_launch: boolean;
+                        created_at: Date;
+                    } | null;
+                    hardware: {
+                        device_name: string;
+                        device_type: string;
+                        device_brand: string;
+                    };
+                    os: {
+                        platform: import("@teardown/types").DevicePlatformEnum;
+                        name: string;
+                        version: string;
+                    };
+                    notifications: {
+                        push: {
+                            enabled: boolean;
+                            granted: boolean;
+                            token: string | null;
+                            platform: import("@teardown/schemas/identify").NotificationPlatform;
+                        };
+                    };
+                    timestamp?: Date | undefined;
+                };
+                persona?: {
+                    user_id?: string | undefined;
+                    email?: string | undefined;
+                    name?: string | undefined;
+                } | undefined;
+            };
+            params: {};
+            query: unknown;
+            headers: {
+                "td-org-id": string;
+                "td-project-id": string;
+                "td-environment-slug": string;
+                authorization?: string | undefined;
+            };
+            response: {
+                200: {
+                    success: true;
+                    session_id: string;
+                    device_id: string;
+                    persona_id: string;
+                    token: string;
+                };
+                400: {
+                    success: false;
+                    error: {
+                        code: "MISSING_ORG_ID";
+                        message: string;
+                    } | {
+                        code: "MISSING_PROJECT_ID";
+                        message: string;
+                    } | {
+                        code: "MISSING_ENVIRONMENT_SLUG";
+                        message: string;
+                    } | {
+                        code: "IDENTIFY_FAILED";
+                        message: string;
+                    } | {
+                        code: "NO_SESSION_ID_GENERATED";
+                        message: string;
+                    } | {
+                        code: "NO_DEVICE_ID_GENERATED";
+                        message: string;
+                    } | {
+                        code: "NO_PERSONA_ID_GENERATED";
+                        message: string;
+                    };
+                };
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+            };
+        };
+    };
+} & {
+    "": {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: {
+                    message: string;
+                    version: string;
+                };
+            };
+        };
+    };
+}>;
 export type Client = ReturnType<typeof client>;
 export type RequestOptions = Omit<NonNullable<Parameters<Client>[1]>, "headers"> & {
     headers?: Record<string, string>;
 };
 export type Endpoints = Parameters<Client>[0];
+export type App = typeof IngestApp;

package/dist/client/types.d.ts

@@ -17,7 +17,23 @@ export type UnionToIntersect<U> = (U extends any ? (arg: U) => any : never) exte
 export type IsAny<T> = 0 extends 1 & T ? true : false;
 export type IsNever<T> = [T] extends [never] ? true : false;
 export type IsUnknown<T> = IsAny<T> extends true ? false : unknown extends T ? true : false;
-export type AnyTypedRoute = {
+export type IsExactlyUnknown<T> = [T] extends [unknown] ? ([unknown] extends [T] ? true : false) : false;
+export type IsUndefined<T> = [T] extends [undefined] ? true : false;
+export type IsMatchingEmptyObject<T> = [T] extends [{}] ? ([{}] extends [T] ? true : false) : false;
+export type MaybeEmptyObject<TObj, TKey extends PropertyKey, TFallback = Record<string, unknown>> = IsUndefined<TObj> extends true ? {
+    [K in TKey]?: TFallback;
+} : IsExactlyUnknown<TObj> extends true ? {
+    [K in TKey]?: TFallback;
+} : IsMatchingEmptyObject<TObj> extends true ? {
+    [K in TKey]?: TObj;
+} : undefined extends TObj ? {
+    [K in TKey]?: TObj;
+} : null extends TObj ? {
+    [K in TKey]?: TObj;
+} : {
+    [K in TKey]: TObj;
+};
+type AnyTypedRoute = {
     body?: unknown;
     headers?: unknown;
     query?: unknown;
@@ -39,36 +55,4 @@ export type TreatyToPath<T, Path extends string = ""> = UnionToIntersect<T exten
     } : TreatyToPath<T[K], `${Path}/${K & string}`>;
 }[keyof T] : {}>;
 export type Not<T> = T extends true ? false : true;
-export type Fn<Schema extends Record<string, any>> = <Endpoint extends keyof Schema, Method extends Uppercase<Extract<keyof Schema[Endpoint], string>>, Route extends Schema[Endpoint][Lowercase<Method>]>(endpoint: Endpoint, options: Omit<RequestInit, "body" | "method" | "headers"> & ("GET" extends Method ? {
-    method?: Method;
-} : {
-    method: Method;
-}) & (IsNever<keyof Route["params"]> extends true ? {
-    params?: Record<never, string>;
-} : {
-    params: Route["params"];
-}) & (IsNever<keyof Route["query"]> extends true ? {
-    query?: Record<never, string>;
-} : {
-    query: Route["query"];
-}) & (undefined extends Route["headers"] ? {
-    headers?: Record<string, string>;
-} : {
-    headers: Route["headers"];
-}) & (IsUnknown<Route["body"]> extends false ? {
-    body: Route["body"];
-} : {
-    body?: unknown;
-})) => Promise<Prettify<{
-    data: Awaited<Route["response"][200]>;
-    error: null;
-    status: number;
-    headers: Record<string, unknown>;
-    retry(): Promise<void>;
-} | {
-    data: null;
-    error: MapError<Route["response"]> extends infer Errors ? IsNever<Errors> extends true ? EdenFetchError<number, string> : Errors : EdenFetchError<number, string>;
-    status: number;
-    headers: Record<string, unknown>;
-    retry(): Promise<void>;
-}>>;
+export {};

package/dist/schemas/index.d.ts

@@ -1 +1 @@
-export * from "./identify.schema";
+export * from "../vendored/schemas/identify";

package/dist/schemas/index.js

@@ -1 +1 @@
-export * from "./identify.schema";
+export * from "../vendored/schemas/identify";

package/dist/types/index.d.ts

@@ -1,2 +1,3 @@
-export type { OSType, DeviceType, ApplicationInfo, OSInfo, HardwareInfo, UpdateInfo, DeviceInfo, PersonaInfo, IdentifyRequest, IdentifyResponse, IdentifyErrorResponse, } from "../schemas/identify.schema";
-export type { IngestApp } from "./app";
+import * as EnvironmentSchemas from "@teardown/schemas/environment";
+import * as IdentifySchemas from "../vendored/schemas/identify";
+export { EnvironmentSchemas, IdentifySchemas };

package/dist/types/index.js

@@ -1 +1,3 @@
-export {};
+import * as EnvironmentSchemas from "@teardown/schemas/environment";
+import * as IdentifySchemas from "../vendored/schemas/identify";
+export { EnvironmentSchemas, IdentifySchemas };

package/dist/{schemas/identify.schema.d.ts → vendored/schemas/identify.d.ts}

@@ -1,19 +1,6 @@
+import { DevicePlatformEnum } from "../types/generated-consts";
 import { z } from "zod";
-/**
- * OS types
- */
-export declare enum OSType {
-    IOS = "IOS",
-    ANDROID = "ANDROID",
-    WEB = "WEB",
-    WINDOWS = "WINDOWS",
-    MACOS = "MACOS",
-    LINUX = "LINUX"
-}
-/**
- * Device types
- */
-export type DeviceType = "UNKNOWN" | "PHONE" | "TABLET" | "DESKTOP" | "CONSOLE" | "TV" | "WEARABLE" | "GAME_CONSOLE" | "VR" | "OTHER";
+export { DevicePlatformEnum };
 /**
  * Application info schema
  */
@@ -26,7 +13,7 @@ export type ApplicationInfo = z.infer<typeof ApplicationInfoSchema>;
  * OS info schema
  */
 export declare const OSInfoSchema: z.ZodObject<{
-    type: z.ZodEnum<typeof OSType>;
+    platform: z.ZodEnum<typeof DevicePlatformEnum>;
     name: z.ZodString;
     version: z.ZodString;
 }, z.core.$strip>;
@@ -67,10 +54,35 @@ export declare const UpdateInfoSchema: z.ZodObject<{
     created_at: z.ZodCoercedDate<unknown>;
 }, z.core.$strip>;
 export type UpdateInfo = z.infer<typeof UpdateInfoSchema>;
+export declare enum NotificationPlatform {
+    APNS = "APNS",// Apple Push Notification Service
+    FCM = "FCM",// Firebase Cloud Messaging
+    EXPO = "EXPO"
+}
+/**
+ * Push notification info schema
+ */
+export declare const PushNotificationInfoSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    granted: z.ZodBoolean;
+    token: z.ZodNullable<z.ZodString>;
+    platform: z.ZodEnum<typeof NotificationPlatform>;
+}, z.core.$strip>;
+export type PushNotificationInfo = z.infer<typeof PushNotificationInfoSchema>;
+export declare const NotificationsInfoSchema: z.ZodObject<{
+    push: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        granted: z.ZodBoolean;
+        token: z.ZodNullable<z.ZodString>;
+        platform: z.ZodEnum<typeof NotificationPlatform>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type NotificationsInfo = z.infer<typeof NotificationsInfoSchema>;
 /**
  * Device info schema
  */
 export declare const DeviceInfoSchema: z.ZodObject<{
+    timestamp: z.ZodOptional<z.ZodCoercedDate<unknown>>;
     application: z.ZodObject<{
         version: z.ZodString;
         build_number: z.ZodString;
@@ -96,10 +108,18 @@ export declare const DeviceInfoSchema: z.ZodObject<{
         device_brand: z.ZodString;
     }, z.core.$strip>;
     os: z.ZodObject<{
-        type: z.ZodEnum<typeof OSType>;
+        platform: z.ZodEnum<typeof DevicePlatformEnum>;
         name: z.ZodString;
         version: z.ZodString;
     }, z.core.$strip>;
+    notifications: z.ZodObject<{
+        push: z.ZodObject<{
+            enabled: z.ZodBoolean;
+            granted: z.ZodBoolean;
+            token: z.ZodNullable<z.ZodString>;
+            platform: z.ZodEnum<typeof NotificationPlatform>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
 }, z.core.$strip>;
 export type DeviceInfo = z.infer<typeof DeviceInfoSchema>;
 /**
@@ -118,6 +138,7 @@ export type PersonaInfo = z.infer<typeof PersonaInfoSchema>;
  */
 export declare const IdentifyRequestSchema: z.ZodObject<{
     device: z.ZodObject<{
+        timestamp: z.ZodOptional<z.ZodCoercedDate<unknown>>;
         application: z.ZodObject<{
             version: z.ZodString;
             build_number: z.ZodString;
@@ -143,10 +164,18 @@ export declare const IdentifyRequestSchema: z.ZodObject<{
             device_brand: z.ZodString;
         }, z.core.$strip>;
         os: z.ZodObject<{
-            type: z.ZodEnum<typeof OSType>;
+            platform: z.ZodEnum<typeof DevicePlatformEnum>;
             name: z.ZodString;
             version: z.ZodString;
         }, z.core.$strip>;
+        notifications: z.ZodObject<{
+            push: z.ZodObject<{
+                enabled: z.ZodBoolean;
+                granted: z.ZodBoolean;
+                token: z.ZodNullable<z.ZodString>;
+                platform: z.ZodEnum<typeof NotificationPlatform>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
     }, z.core.$strip>;
     persona: z.ZodOptional<z.ZodObject<{
         user_id: z.ZodOptional<z.ZodString>;
@@ -163,13 +192,37 @@ export declare const IdentifyResponseSchema: z.ZodObject<{
     session_id: z.ZodString;
     device_id: z.ZodString;
     persona_id: z.ZodString;
+    token: z.ZodString;
 }, z.core.$strip>;
 export type IdentifyResponse = z.infer<typeof IdentifyResponseSchema>;
 export declare const IdentifyErrorResponseSchema: z.ZodObject<{
     success: z.ZodLiteral<false>;
-    error: z.ZodObject<{
-        code: z.ZodString;
+    error: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        code: z.ZodLiteral<"MISSING_ORG_ID">;
         message: z.ZodString;
-    }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        code: z.ZodLiteral<"MISSING_PROJECT_ID">;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        code: z.ZodLiteral<"MISSING_ENVIRONMENT_SLUG">;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        code: z.ZodLiteral<"IDENTIFY_FAILED">;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        code: z.ZodLiteral<"NO_SESSION_ID_GENERATED">;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        code: z.ZodLiteral<"NO_DEVICE_ID_GENERATED">;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        code: z.ZodLiteral<"NO_PERSONA_ID_GENERATED">;
+        message: z.ZodString;
+    }, z.core.$strip>], "code">;
 }, z.core.$strip>;
 export type IdentifyErrorResponse = z.infer<typeof IdentifyErrorResponseSchema>;
+export declare const ValidationErrorSchema: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodLiteral<"VALIDATION">;
+    message: z.ZodString;
+}, z.core.$strip>;

package/dist/vendored/schemas/identify.js

@@ -0,0 +1,203 @@
+import { DevicePlatformEnum } from "../types/generated-consts";
+import { ValidationError } from "elysia";
+import { z } from "zod";
+export { DevicePlatformEnum };
+/**
+ * Application info schema
+ */
+export const ApplicationInfoSchema = z.object({
+    version: z.string("version is required"),
+    build_number: z.string("build_number is required"),
+}, {
+    error: "Application info is required",
+});
+/**
+ * OS info schema
+ */
+export const OSInfoSchema = z.object({
+    /**
+     * Device platform
+     */
+    platform: z.enum(DevicePlatformEnum, "platform is required"),
+    /**
+     * OS name
+     */
+    name: z.string("name is required"),
+    /**
+     * OS version
+     */
+    version: z.string("version is required"),
+}, {
+    error: "OS info is required",
+});
+/**
+ * Hardware info schema
+ */
+export const HardwareInfoSchema = z.object({
+    device_name: z.string("device_name is required"),
+    device_type: z.string("device_type is required"),
+    device_brand: z.string("device_brand is required"),
+}, {
+    error: "Hardware info is required",
+});
+export const EmergencyLaunchSchema = z.union([
+    z.object({
+        is_emergency_launch: z.literal(true),
+        reason: z.string("reason is required when is_emergency_launch is true"),
+    }),
+    z.object({
+        is_emergency_launch: z.literal(false),
+        reason: z.never().optional(),
+    }),
+], {
+    error: "Emergency launch is required",
+});
+/**
+ * Update info schema
+ */
+export const UpdateInfoSchema = z.object({
+    is_enabled: z.boolean(),
+    update_id: z.string("update_id is required"),
+    update_channel: z.string("update_channel is required"),
+    runtime_version: z.string("runtime_version is required"),
+    emergency_launch: EmergencyLaunchSchema,
+    is_embedded_launch: z.boolean("is_embedded_launch is required"),
+    created_at: z.coerce.date(),
+}, {
+    error: "Update info is required",
+});
+export var NotificationPlatform;
+(function (NotificationPlatform) {
+    NotificationPlatform["APNS"] = "APNS";
+    NotificationPlatform["FCM"] = "FCM";
+    NotificationPlatform["EXPO"] = "EXPO";
+})(NotificationPlatform || (NotificationPlatform = {}));
+/**
+ * Push notification info schema
+ */
+export const PushNotificationInfoSchema = z.object({
+    enabled: z.boolean("enabled is required"),
+    granted: z.boolean("granted is required"),
+    token: z.string("token is required").nullable(),
+    platform: z.enum(NotificationPlatform, "platform is required"),
+}, {
+    error: "Push notification info is required",
+});
+export const NotificationsInfoSchema = z.object({
+    push: PushNotificationInfoSchema,
+}, {
+    error: "Notifications info is required",
+});
+/**
+ * Device info schema
+ */
+export const DeviceInfoSchema = z.object({
+    /**
+     * Timestamp of collection on device (optional, generated server-side if not provided)
+     */
+    timestamp: z.coerce.date("timestamp is required").optional(),
+    /**
+     * Application info, required
+     */
+    application: ApplicationInfoSchema,
+    /**
+     * Update info (optional) - not all builds will have an update
+     */
+    update: UpdateInfoSchema.nullable(),
+    /**
+     * Hardware info, required
+     */
+    hardware: HardwareInfoSchema,
+    /**
+     * OS info, required
+     */
+    os: OSInfoSchema,
+    /**
+     * Notifications info, required
+     */
+    notifications: NotificationsInfoSchema,
+}, {
+    error: "Device info is required",
+});
+/**
+ * Persona info schema (optional fields)
+ * Matches personas table structure
+ */
+export const PersonaInfoSchema = z.object({
+    user_id: z.string("user_id is required").optional(),
+    email: z
+        .string("email is required")
+        .refine((val) => !val || /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(val), {
+        message: "Invalid email format",
+    })
+        .optional(),
+    name: z.string("name is required").optional(),
+}, {
+    error: "Persona info is required",
+});
+/**
+ * Identify request schema
+ * Ties a device to a persona with optional persona data
+ */
+export const IdentifyRequestSchema = z.object({
+    device: DeviceInfoSchema,
+    persona: PersonaInfoSchema.optional(),
+}, {
+    error: "Identify request is required",
+});
+/**
+ * Identify response schema
+ */
+export const IdentifyResponseSchema = z.object({
+    success: z.literal(true),
+    session_id: z.string("session_id is required"),
+    device_id: z.string("device_id is required"),
+    persona_id: z.string("persona_id is required"),
+    token: z.string("token is required"), // JWT token for session authentication
+}, {
+    error: "Identify response is required",
+});
+export const IdentifyErrorResponseSchema = z.object({
+    success: z.literal(false),
+    error: z.discriminatedUnion("code", [
+        z.object({
+            code: z.literal("MISSING_ORG_ID"),
+            message: z.string(),
+        }),
+        z.object({
+            code: z.literal("MISSING_PROJECT_ID"),
+            message: z.string(),
+        }),
+        z.object({
+            code: z.literal("MISSING_ENVIRONMENT_SLUG"),
+            message: z.string(),
+        }),
+        z.object({
+            code: z.literal("IDENTIFY_FAILED"),
+            message: z.string(),
+        }),
+        z.object({
+            code: z.literal("NO_SESSION_ID_GENERATED"),
+            message: z.string(),
+        }),
+        z.object({
+            code: z.literal("NO_DEVICE_ID_GENERATED"),
+            message: z.string(),
+        }),
+        z.object({
+            code: z.literal("NO_PERSONA_ID_GENERATED"),
+            message: z.string(),
+        }),
+    ]),
+}, {
+    error: "Identify error response is required",
+});
+export const ValidationErrorSchema = z.object({
+    success: z.literal(false),
+    error: z.literal("VALIDATION"),
+    message: z.string(),
+}, {
+    error: "Validation error is required",
+});
+// export type ValidationError = z.infer<typeof ValidationErrorSchema>;
+ValidationError;

package/dist/vendored/types/generated-consts.d.ts

@@ -0,0 +1,47 @@
+export declare enum DevicePlatformEnum {
+    IOS = "IOS",
+    ANDROID = "ANDROID",
+    WEB = "WEB",
+    WINDOWS = "WINDOWS",
+    MACOS = "MACOS",
+    LINUX = "LINUX",
+    PHONE = "PHONE",
+    TABLET = "TABLET",
+    DESKTOP = "DESKTOP",
+    CONSOLE = "CONSOLE",
+    TV = "TV",
+    WEARABLE = "WEARABLE",
+    GAME_CONSOLE = "GAME_CONSOLE",
+    VR = "VR",
+    UNKNOWN = "UNKNOWN",
+    OTHER = "OTHER"
+}
+export declare enum EnvironmentTypeEnum {
+    DEVELOPMENT = "DEVELOPMENT",
+    STAGING = "STAGING",
+    PRODUCTION = "PRODUCTION"
+}
+export declare enum OrgRoleTypeEnum {
+    OWNER = "OWNER",
+    ADMIN = "ADMIN",
+    ENGINEER = "ENGINEER"
+}
+export declare enum OrgTypeEnum {
+    PERSONAL = "PERSONAL",
+    START_UP = "START_UP",
+    SCALE_UP = "SCALE_UP",
+    AGENCY = "AGENCY",
+    ENTERPRISE = "ENTERPRISE"
+}
+export declare enum ProjectApiKeyKindEnum {
+    publishable = "publishable",
+    secret = "secret"
+}
+export declare enum ProjectTypeEnum {
+    REACT_NATIVE = "REACT_NATIVE",
+    EXPO = "EXPO"
+}
+export declare enum VersionStatusEnum {
+    LIVE = "LIVE",
+    DISABLED = "DISABLED"
+}

package/dist/vendored/types/generated-consts.js

@@ -0,0 +1,54 @@
+export var DevicePlatformEnum;
+(function (DevicePlatformEnum) {
+    DevicePlatformEnum["IOS"] = "IOS";
+    DevicePlatformEnum["ANDROID"] = "ANDROID";
+    DevicePlatformEnum["WEB"] = "WEB";
+    DevicePlatformEnum["WINDOWS"] = "WINDOWS";
+    DevicePlatformEnum["MACOS"] = "MACOS";
+    DevicePlatformEnum["LINUX"] = "LINUX";
+    DevicePlatformEnum["PHONE"] = "PHONE";
+    DevicePlatformEnum["TABLET"] = "TABLET";
+    DevicePlatformEnum["DESKTOP"] = "DESKTOP";
+    DevicePlatformEnum["CONSOLE"] = "CONSOLE";
+    DevicePlatformEnum["TV"] = "TV";
+    DevicePlatformEnum["WEARABLE"] = "WEARABLE";
+    DevicePlatformEnum["GAME_CONSOLE"] = "GAME_CONSOLE";
+    DevicePlatformEnum["VR"] = "VR";
+    DevicePlatformEnum["UNKNOWN"] = "UNKNOWN";
+    DevicePlatformEnum["OTHER"] = "OTHER";
+})(DevicePlatformEnum || (DevicePlatformEnum = {}));
+export var EnvironmentTypeEnum;
+(function (EnvironmentTypeEnum) {
+    EnvironmentTypeEnum["DEVELOPMENT"] = "DEVELOPMENT";
+    EnvironmentTypeEnum["STAGING"] = "STAGING";
+    EnvironmentTypeEnum["PRODUCTION"] = "PRODUCTION";
+})(EnvironmentTypeEnum || (EnvironmentTypeEnum = {}));
+export var OrgRoleTypeEnum;
+(function (OrgRoleTypeEnum) {
+    OrgRoleTypeEnum["OWNER"] = "OWNER";
+    OrgRoleTypeEnum["ADMIN"] = "ADMIN";
+    OrgRoleTypeEnum["ENGINEER"] = "ENGINEER";
+})(OrgRoleTypeEnum || (OrgRoleTypeEnum = {}));
+export var OrgTypeEnum;
+(function (OrgTypeEnum) {
+    OrgTypeEnum["PERSONAL"] = "PERSONAL";
+    OrgTypeEnum["START_UP"] = "START_UP";
+    OrgTypeEnum["SCALE_UP"] = "SCALE_UP";
+    OrgTypeEnum["AGENCY"] = "AGENCY";
+    OrgTypeEnum["ENTERPRISE"] = "ENTERPRISE";
+})(OrgTypeEnum || (OrgTypeEnum = {}));
+export var ProjectApiKeyKindEnum;
+(function (ProjectApiKeyKindEnum) {
+    ProjectApiKeyKindEnum["publishable"] = "publishable";
+    ProjectApiKeyKindEnum["secret"] = "secret";
+})(ProjectApiKeyKindEnum || (ProjectApiKeyKindEnum = {}));
+export var ProjectTypeEnum;
+(function (ProjectTypeEnum) {
+    ProjectTypeEnum["REACT_NATIVE"] = "REACT_NATIVE";
+    ProjectTypeEnum["EXPO"] = "EXPO";
+})(ProjectTypeEnum || (ProjectTypeEnum = {}));
+export var VersionStatusEnum;
+(function (VersionStatusEnum) {
+    VersionStatusEnum["LIVE"] = "LIVE";
+    VersionStatusEnum["DISABLED"] = "DISABLED";
+})(VersionStatusEnum || (VersionStatusEnum = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@teardown/ingest-api",
-	"version": "0.0.18",
+	"version": "0.0.21-alpha.10",
 	"private": false,
 	"publishConfig": {
 		"access": "public"
@@ -24,29 +24,33 @@
 		},
 		"./types": {
 			"types": "./dist/types/index.d.ts"
+		},
+		"./vendored/consts": {
+			"types": "./dist/vendored/types/generated-consts.d.ts",
+			"import": "./dist/vendored/types/generated-consts.js",
+			"default": "./dist/vendored/types/generated-consts.js"
 		}
 	},
 	"scripts": {
-		"sync:schemas": "bun run scripts/sync-schemas.ts",
-		"postinstall": "bun run sync:schemas",
-		"build": "tsc --project ./tsconfig.lib.json",
-		"predev": "bun run sync:schemas",
-		"dev": "rm -rf dist; bun x tsc --watch --project ./tsconfig.lib.json",
-		"check:types": "tsc --noEmit --project ./tsconfig.lib.json",
-		"prepublishOnly": "bun run sync:schemas && bun run build"
+		"copy:schemas": "bun run scripts/copy-schemas.ts",
+		"prebuild": "bun run copy:schemas",
+		"build": "bun x tsc --project ./tsconfig.lib.json",
+		"dev": "bun x tsc --watch --project ./tsconfig.lib.json",
+		"check:types": "bun x tsc --noEmit --project ./tsconfig.lib.json",
+		"prepublishOnly": "bun x turbo run build"
 	},
 	"dependencies": {
-		"@elysiajs/eden": "^1.4.4",
-		"elysia": "^1.4.13"
+		"@elysiajs/eden": "1.4.5"
 	},
 	"peerDependencies": {
-		"typescript": "^5",
-		"zod": "^4"
+		"typescript": "^5.9.3",
+		"zod": "^4",
+		"elysia": ">= 1.4.0"
 	},
 	"devDependencies": {
-		"@types/bun": "latest",
+		"@types/bun": "1.3.3",
 		"@teardown/ingest": "0.0.1",
 		"@teardown/tsconfig": "1.0.0",
-		"@teardown/types": "0.0.1"
+		"elysia": "1.4.0"
 	}
 }

package/dist/schemas/identify.schema.js

@@ -1,120 +0,0 @@
-import { z } from "zod";
-/**
- * OS types
- */
-export var OSType;
-(function (OSType) {
-    OSType["IOS"] = "IOS";
-    OSType["ANDROID"] = "ANDROID";
-    OSType["WEB"] = "WEB";
-    OSType["WINDOWS"] = "WINDOWS";
-    OSType["MACOS"] = "MACOS";
-    OSType["LINUX"] = "LINUX";
-})(OSType || (OSType = {}));
-/**
- * Application info schema
- */
-export const ApplicationInfoSchema = z.object({
-    version: z.string(),
-    build_number: z.string(),
-});
-/**
- * OS info schema
- */
-export const OSInfoSchema = z.object({
-    /**
-     * OS type
-     */
-    type: z.enum(OSType),
-    name: z.string(),
-    version: z.string(),
-});
-/**
- * Hardware info schema
- */
-export const HardwareInfoSchema = z.object({
-    device_name: z.string(),
-    device_type: z.string(),
-    device_brand: z.string(),
-});
-export const EmergencyLaunchSchema = z.union([
-    z.object({
-        is_emergency_launch: z.literal(true),
-        reason: z.string(),
-    }),
-    z.object({
-        is_emergency_launch: z.literal(false),
-        reason: z.never().optional(),
-    }),
-]);
-/**
- * Update info schema
- */
-export const UpdateInfoSchema = z.object({
-    is_enabled: z.boolean(),
-    update_id: z.string(),
-    update_channel: z.string(),
-    runtime_version: z.string(),
-    emergency_launch: EmergencyLaunchSchema,
-    is_embedded_launch: z.boolean(),
-    created_at: z.coerce.date(),
-});
-/**
- * Device info schema
- */
-export const DeviceInfoSchema = z.object({
-    /**
-     * Application info, required
-     */
-    application: ApplicationInfoSchema,
-    /**
-     * Update info (optional) - not all builds will have an update
-     */
-    update: UpdateInfoSchema.nullable(),
-    /**
-     * Hardware info, required
-     */
-    hardware: HardwareInfoSchema,
-    /**
-     * OS info, required
-     */
-    os: OSInfoSchema,
-});
-/**
- * Persona info schema (optional fields)
- * Matches personas table structure
- */
-export const PersonaInfoSchema = z.object({
-    user_id: z.string().optional(),
-    email: z
-        .string()
-        .refine((val) => !val || /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(val), {
-        message: "Invalid email format",
-    })
-        .optional(),
-    name: z.string().optional(),
-});
-/**
- * Identify request schema
- * Ties a device to a persona with optional persona data
- */
-export const IdentifyRequestSchema = z.object({
-    device: DeviceInfoSchema,
-    persona: PersonaInfoSchema.optional(),
-});
-/**
- * Identify response schema
- */
-export const IdentifyResponseSchema = z.object({
-    success: z.literal(true),
-    session_id: z.string(),
-    device_id: z.string(),
-    persona_id: z.string(),
-});
-export const IdentifyErrorResponseSchema = z.object({
-    success: z.literal(false),
-    error: z.object({
-        code: z.string(),
-        message: z.string(),
-    }),
-});

package/dist/types/app.d.ts

@@ -1,9 +0,0 @@
-import type { Elysia } from "elysia";
-/**
- * Type placeholder for IngestApp
- * This should match the type from @teardown/ingest but is defined here
- * to avoid runtime dependency on the private package
- *
- * When developing locally, you can override this with the actual type from @teardown/ingest
- */
-export type IngestApp = Elysia<any>;

package/dist/types/app.js

@@ -1 +0,0 @@
-export {};