@biteasy/javascript-sdk 1.0.1 → 1.0.3

package/dist/gen/core/utils.gen.d.ts

@@ -0,0 +1,19 @@
+import type { BodySerializer, QuerySerializer } from './bodySerializer.gen';
+export interface PathSerializer {
+    path: Record<string, unknown>;
+    url: string;
+}
+export declare const PATH_PARAM_RE: RegExp;
+export declare const defaultPathSerializer: ({ path, url: _url }: PathSerializer) => string;
+export declare const getUrl: ({ baseUrl, path, query, querySerializer, url: _url, }: {
+    baseUrl?: string;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    querySerializer: QuerySerializer;
+    url: string;
+}) => string;
+export declare function getValidRequestBody(options: {
+    body?: unknown;
+    bodySerializer?: BodySerializer | null;
+    serializedBody?: unknown;
+}): unknown;

package/dist/gen/index.d.ts

@@ -0,0 +1,2 @@
+export { type Options, v1Claim, v1Defer, v1DeferPreflight } from "./sdk.gen";
+export type { ClientOptions, V1ClaimData, V1ClaimResponse, V1ClaimResponses, V1DeferData, V1DeferPreflightData, V1DeferPreflightResponse, V1DeferPreflightResponses, V1DeferResponse, V1DeferResponses, } from "./types.gen";

package/dist/gen/sdk.gen.d.ts

@@ -0,0 +1,59 @@
+import type { Client, Options as Options2, TDataShape } from './client';
+import type { V1ClaimData, V1ClaimResponses, V1DeferData, V1DeferPreflightData, V1DeferPreflightResponses, V1DeferResponses } from './types.gen';
+export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean> = Options2<TData, ThrowOnError> & {
+    /**
+     * You can provide a client instance returned by `createClient()` instead of
+     * individual options. This might be also useful if you want to implement a
+     * custom client.
+     */
+    client?: Client;
+    /**
+     * You can pass arbitrary values through the `meta` object. This can be
+     * used to access values that aren't defined as part of the SDK function.
+     */
+    meta?: Record<string, unknown>;
+};
+/**
+ * Claim referral intent
+ *
+ * Claim a referral intent
+ *
+ * Use this endpoint to attribute an app installation to a referral partner.
+ *
+ * Attribution can happen in one of two ways, depending on the request:
+ *
+ * 1. Explicit claim (recommended)
+ *
+ * If a `claimCode` is provided, the referral intent is claimed deterministically using that code.
+ * This is the preferred and most reliable attribution method.
+ *
+ * 2. Time-window auto-claim (best-effort)
+ *
+ * If no `claimCode` is provided, the request opts into time-window auto-claiming.
+ *
+ * In this mode, BitEasy will attempt to attribute the installation to exactly one recent referral intent created shortly before install.
+ * If no eligible intent exists — or if attribution would be ambiguous — no attribution is made.
+ */
+export declare const v1Claim: <ThrowOnError extends boolean = false>(options: Options<V1ClaimData, ThrowOnError>) => import("./client").RequestResult<V1ClaimResponses, unknown, ThrowOnError, "fields">;
+/**
+ * Issue referral claim code
+ *
+ * Issues a short-lived referral claim code that can be shown to a user before they install the app.
+ *
+ * This is the explicit attribution entry point: the user copies or scans the code and later pastes it in-app to complete attribution.
+ *
+ * Platform attribution (iOS / Android) is recorded separately via the `/defer` endpoint.
+ *
+ */
+export declare const v1DeferPreflight: <ThrowOnError extends boolean = false>(options: Options<V1DeferPreflightData, ThrowOnError>) => import("./client").RequestResult<V1DeferPreflightResponses, unknown, ThrowOnError, "fields">;
+/**
+ * Defer referral intent
+ *
+ * Register a referral intent.
+ *
+ * The intent is identified by a claim code, which is a unique identifier for the intent. Another option is to use a time based identifier.
+ *
+ * The intent is claimed by the user who is making the request.
+ *
+ */
+export declare const v1Defer: <ThrowOnError extends boolean = false>(options: Options<V1DeferData, ThrowOnError>) => import("./client").RequestResult<V1DeferResponses, unknown, ThrowOnError, "fields">;

package/dist/gen/types.gen.d.ts

@@ -0,0 +1,78 @@
+export type ClientOptions = {
+    baseUrl: `${string}://${string}/api/v1` | (string & {});
+};
+export type V1ClaimData = {
+    body: {
+        appId: string;
+        installId: string;
+        platform: 'ios' | 'android';
+        claimCode?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/v1/claim';
+};
+export type V1ClaimResponses = {
+    /**
+     * OK
+     */
+    200: {
+        referrer: string | null;
+        path: string | null;
+        paywall: {
+            id?: string;
+            offerCode: {
+                code: string;
+                expiresAt: string;
+                platform: 'ios' | 'android';
+                subscriptionDuration: 'monthly' | 'yearly';
+            };
+            partner: string;
+            source: 'partner';
+        } | null;
+        status: 'claimed' | 'already_claimed' | 'not_found' | 'invalid_code' | 'limit_exceeded';
+    };
+};
+export type V1ClaimResponse = V1ClaimResponses[keyof V1ClaimResponses];
+export type V1DeferPreflightData = {
+    body: {
+        appId: string;
+        referrer: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/v1/defer-preflight';
+};
+export type V1DeferPreflightResponses = {
+    /**
+     * OK
+     */
+    200: {
+        success: boolean;
+        claimCode: string;
+        expiresAt: string;
+    };
+};
+export type V1DeferPreflightResponse = V1DeferPreflightResponses[keyof V1DeferPreflightResponses];
+export type V1DeferData = {
+    body: {
+        appId: string;
+        referrer: string;
+        platform: 'ios' | 'android';
+        path?: string;
+        claimCode?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/v1/defer';
+};
+export type V1DeferResponses = {
+    /**
+     * OK
+     */
+    200: {
+        success: boolean;
+        expiresAt?: string;
+    };
+};
+export type V1DeferResponse = V1DeferResponses[keyof V1DeferResponses];

package/dist/gen/zod.gen.d.ts

@@ -0,0 +1,84 @@
+import * as z from 'zod';
+export declare const zV1ClaimData: z.ZodObject<{
+    body: z.ZodObject<{
+        appId: z.ZodUUID;
+        installId: z.ZodString;
+        platform: z.ZodEnum<{
+            ios: "ios";
+            android: "android";
+        }>;
+        claimCode: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    path: z.ZodOptional<z.ZodNever>;
+    query: z.ZodOptional<z.ZodNever>;
+}, z.core.$strip>;
+/**
+ * OK
+ */
+export declare const zV1ClaimResponse: z.ZodObject<{
+    referrer: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+    path: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+    paywall: z.ZodUnion<readonly [z.ZodObject<{
+        id: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        offerCode: z.ZodObject<{
+            code: z.ZodString;
+            expiresAt: z.ZodString;
+            platform: z.ZodEnum<{
+                ios: "ios";
+                android: "android";
+            }>;
+            subscriptionDuration: z.ZodEnum<{
+                monthly: "monthly";
+                yearly: "yearly";
+            }>;
+        }, z.core.$strip>;
+        partner: z.ZodString;
+        source: z.ZodEnum<{
+            partner: "partner";
+        }>;
+    }, z.core.$strip>, z.ZodNull]>;
+    status: z.ZodEnum<{
+        claimed: "claimed";
+        already_claimed: "already_claimed";
+        not_found: "not_found";
+        invalid_code: "invalid_code";
+        limit_exceeded: "limit_exceeded";
+    }>;
+}, z.core.$strip>;
+export declare const zV1DeferPreflightData: z.ZodObject<{
+    body: z.ZodObject<{
+        appId: z.ZodUUID;
+        referrer: z.ZodString;
+    }, z.core.$strip>;
+    path: z.ZodOptional<z.ZodNever>;
+    query: z.ZodOptional<z.ZodNever>;
+}, z.core.$strip>;
+/**
+ * OK
+ */
+export declare const zV1DeferPreflightResponse: z.ZodObject<{
+    success: z.ZodBoolean;
+    claimCode: z.ZodString;
+    expiresAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export declare const zV1DeferData: z.ZodObject<{
+    body: z.ZodObject<{
+        appId: z.ZodUUID;
+        referrer: z.ZodString;
+        platform: z.ZodEnum<{
+            ios: "ios";
+            android: "android";
+        }>;
+        path: z.ZodOptional<z.ZodString>;
+        claimCode: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    path: z.ZodOptional<z.ZodNever>;
+    query: z.ZodOptional<z.ZodNever>;
+}, z.core.$strip>;
+/**
+ * OK
+ */
+export declare const zV1DeferResponse: z.ZodObject<{
+    success: z.ZodBoolean;
+    expiresAt: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strip>;

package/dist/index.d.ts

@@ -1,27 +1,65 @@
-import { ClaimRequestSchema, ClaimResponseSchema, DeferInputSchema, DeferOutputSchema, DeferPreflightInputSchema, DeferPreflightOutputSchema } from "@biteasy/contracts";
-export { ClaimRequestSchema, ClaimResponseSchema, DeferInputSchema, DeferOutputSchema, DeferPreflightInputSchema, DeferPreflightOutputSchema, };
-import { z } from "zod";
+import type { V1ClaimResponse, V1DeferPreflightResponse, V1DeferResponse } from "./gen/types.gen";
+export type { V1ClaimResponse, V1DeferPreflightResponse, V1DeferResponse };
+export type BitEasyClient = {
+    appId: string;
+    version: string;
+};
 export type BitEasyClientConfig = {
     appId: string;
-    baseUrl?: string;
+    /** @default "1" */
     version?: string;
+    /** @default "https://api.biteasy.com/api" */
+    baseUrl?: string;
+    /** Custom fetch implementation for environments where globalThis.fetch is unavailable. */
     fetch?: typeof fetch;
 };
-export type BitEasyClient = {
-    appId: string;
-    apiBaseUrl: string;
-    fetch: typeof fetch;
-};
-export declare function createBitEasyClient(config: BitEasyClientConfig): BitEasyClient;
-export declare function deferPreflight(client: BitEasyClient, params: Omit<DeferPreflightInput, "appId">): Promise<DeferPreflightOutput>;
-export declare function defer(client: BitEasyClient, params: Omit<DeferInput, "appId">): Promise<DeferOutput>;
-export declare function claimAttribution(client: BitEasyClient, params: Omit<ClaimAttributionInput, "appId">): Promise<ClaimResponse>;
-export type DeferPreflightInput = z.infer<typeof DeferPreflightInputSchema>;
-export type DeferPreflightOutput = z.infer<typeof DeferPreflightOutputSchema>;
-export type DeferPreflightParams = Omit<DeferPreflightInput, "appId">;
-export type DeferInput = z.infer<typeof DeferInputSchema>;
-export type DeferOutput = z.infer<typeof DeferOutputSchema>;
-export type DeferParams = Omit<DeferInput, "appId">;
-export type ClaimAttributionInput = z.infer<typeof ClaimRequestSchema>;
-export type ClaimResponse = z.infer<typeof ClaimResponseSchema>;
-export type ClaimAttributionParams = Omit<ClaimAttributionInput, "appId">;
+/**
+ * Create a BitEasy client instance.
+ *
+ * @example
+ * ```ts
+ * import { createClient, claim } from "@biteasy/javascript-sdk";
+ *
+ * const client = createClient({ appId: "your-app-id" });
+ * const result = await claim(client, { installId: "...", platform: "ios" });
+ * ```
+ */
+export declare function createClient(config: BitEasyClientConfig): BitEasyClient;
+/**
+ * Claim a referral intent.
+ *
+ * Use this to attribute an app installation to a referral partner.
+ * If a `claimCode` is provided, attribution is deterministic.
+ * Otherwise, time-window auto-claiming is attempted.
+ *
+ * @throws On non-2xx responses.
+ */
+export declare function claimAttribution(client: BitEasyClient, params: {
+    installId: string;
+    platform: "ios" | "android";
+    claimCode?: string;
+}): Promise<V1ClaimResponse>;
+/**
+ * Issue a short-lived referral claim code.
+ *
+ * The code can be shown to a user before they install the app.
+ * Platform attribution is recorded separately via {@link defer}.
+ *
+ * @throws On non-2xx responses.
+ */
+export declare function deferPreflight(client: BitEasyClient, params: {
+    referrer: string;
+}): Promise<V1DeferPreflightResponse>;
+/**
+ * Register a referral intent.
+ *
+ * The intent is identified by a claim code or via time-based attribution.
+ *
+ * @throws On non-2xx responses.
+ */
+export declare function defer(client: BitEasyClient, params: {
+    referrer: string;
+    platform: "ios" | "android";
+    path?: string;
+    claimCode?: string;
+}): Promise<V1DeferResponse>;