npm - @teardown/ingest-api - Versions diffs - 0.0.20 → 0.0.21-alpha.10 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/dist/client/client.d.ts +137 -3
package/dist/client/types.d.ts +18 -34
package/dist/schemas/index.d.ts +1 -1
package/dist/schemas/index.js +1 -1
package/dist/types/index.d.ts +3 -2
package/dist/types/index.js +3 -1
package/dist/{schemas/identify.schema.d.ts → vendored/schemas/identify.d.ts} +68 -43
package/dist/vendored/schemas/identify.js +203 -0
package/dist/vendored/types/generated-consts.d.ts +47 -0
package/dist/vendored/types/generated-consts.js +54 -0
package/package.json +18 -14
package/dist/schemas/identify.schema.js +0 -131
package/dist/types/app.d.ts +0 -9
package/dist/types/app.js +0 -1

package/dist/client/client.d.ts CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

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

package/dist/schemas/index.js CHANGED Viewed

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

package/dist/types/index.d.ts CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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} RENAMED Viewed

@@ -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,22 +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<{
-    token: z.ZodString;
-    platform: z.ZodEnum<{
-        APNS: "APNS";
-        FCM: "FCM";
-        EXPO: "EXPO";
-    }>;
+    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;
@@ -108,18 +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>;
-    push_notification: z.ZodOptional<z.ZodObject<{
-        token: z.ZodString;
-        platform: z.ZodEnum<{
-            APNS: "APNS";
-            FCM: "FCM";
-            EXPO: "EXPO";
-        }>;
-    }, 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>;
 /**
@@ -138,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;
@@ -163,18 +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>;
-        push_notification: z.ZodOptional<z.ZodObject<{
-            token: z.ZodString;
-            platform: z.ZodEnum<{
-                APNS: "APNS";
-                FCM: "FCM";
-                EXPO: "EXPO";
-            }>;
-        }, 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>;
@@ -191,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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 CHANGED Viewed

@@ -1,6 +1,6 @@
 {
 	"name": "@teardown/ingest-api",
-	"version": "0.0.20",
+	"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 DELETED Viewed

@@ -1,131 +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(),
-});
-/**
- * Push notification info schema
- */
-export const PushNotificationInfoSchema = z.object({
-    token: z.string(),
-    platform: z.enum(["APNS", "FCM", "EXPO"]),
-});
-/**
- * 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,
-    /**
-     * Push notification info, optional
-     */
-    push_notification: PushNotificationInfoSchema.optional(),
-});
-/**
- * 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 DELETED Viewed

@@ -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 DELETED Viewed

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