shipos 0.1.0

package/README.md

@@ -0,0 +1,225 @@
+# @shipos/sdk
+
+Official SDK for ShipOS feature flags, global configs, and customer identification.
+
+## Installation
+
+```bash
+bun add @shipos/sdk
+# or
+npm install @shipos/sdk
+```
+
+## Quick Start
+
+### Basic Usage (Vanilla JS/TS)
+
+```typescript
+import { createShipOS } from '@shipos/sdk';
+
+const shipos = createShipOS({
+  apiKey: 'your-api-key',
+  environment: 'production', // optional, defaults to 'production'
+});
+
+// Identify a customer
+await shipos.customers.signIn({
+  externalId: 'user-123',
+  metadata: { name: 'Jane', plan: 'pro' },
+});
+
+// Get all feature flags
+const flags = await shipos.featureFlags.getAll();
+console.log(flags); // { 'new-feature': true, 'beta-mode': false }
+
+// Get a single flag with default value
+const isEnabled = await shipos.featureFlags.get('new-feature', false);
+
+// Get a typed config
+interface PricingConfig {
+  plans: Array<{ name: string; price: number }>;
+}
+const pricing = await shipos.configs.get<PricingConfig>('pricing');
+```
+
+### React Integration
+
+```tsx
+import { ShipOSProvider, useFlag, useCustomer, Feature } from '@shipos/sdk/react';
+
+// Wrap your app with the provider
+function App() {
+  return (
+    <ShipOSProvider config={{ apiKey: 'your-api-key' }}>
+      <MyApp />
+    </ShipOSProvider>
+  );
+}
+
+// Identify users with useCustomer
+function MyApp() {
+  const { signIn } = useCustomer();
+
+  useEffect(() => {
+    signIn({ externalId: 'user-123', metadata: { plan: 'pro' } });
+  }, []);
+
+  return <Dashboard />;
+}
+
+// Use hooks in your components
+function Dashboard() {
+  const { enabled, isLoading } = useFlag('new-feature');
+
+  if (isLoading) return <div>Loading...</div>;
+
+  return enabled ? <NewFeature /> : <OldFeature />;
+}
+
+// Or use the Feature component
+function AnotherComponent() {
+  return (
+    <Feature flag="new-dashboard" fallback={<OldDashboard />}>
+      <NewDashboard />
+    </Feature>
+  );
+}
+```
+
+## API Reference
+
+### Core Client
+
+#### `createShipOS(config)`
+
+Creates a new ShipOS client instance.
+
+```typescript
+const shipos = createShipOS({
+  apiKey: string;        // Required: Your API key
+  baseUrl?: string;      // Optional: API base URL
+  environment?: string;  // Optional: Environment (default: 'production')
+  cacheTTL?: number;     // Optional: Cache TTL in ms (default: 60000)
+  debug?: boolean;       // Optional: Enable debug logging
+});
+```
+
+### Customers
+
+- `customers.signIn({ externalId, metadata? })` - Identify a customer
+- `customers.signOut()` - Clear customer context
+- `customers.get()` - Get current customer or null
+
+### Feature Flags
+
+- `featureFlags.getAll()` - Get all feature flags
+- `featureFlags.get(key, defaultValue?)` - Get a single flag
+- `featureFlags.refresh()` - Refresh flags (bypass cache)
+
+### Global Configs
+
+- `configs.get<T>(slug)` - Get a config by slug
+- `configs.refresh<T>(slug)` - Refresh a config (bypass cache)
+
+### Utilities
+
+- `clearCache()` - Clear the cache
+- `setEnvironment(env)` - Change environment
+- `getEnvironment()` - Get current environment
+
+### React Hooks
+
+#### `useCustomer()`
+
+Manage customer identification.
+
+```typescript
+const { customer, signIn, signOut } = useCustomer();
+```
+
+#### `useFlags()`
+
+Get all feature flags.
+
+```typescript
+const { flags, isLoading, error, refreshFlags } = useFlags();
+```
+
+#### `useFlag(key, defaultValue?)`
+
+Get a single feature flag.
+
+```typescript
+const { enabled, isLoading, error } = useFlag('my-feature', false);
+```
+
+#### `useConfig<T>(slug)`
+
+Get a configuration by slug.
+
+```typescript
+const { config, isLoading, error, refresh } = useConfig<MyConfig>('my-config');
+```
+
+### React Components
+
+#### `<Feature>`
+
+Conditionally render based on a flag.
+
+```tsx
+<Feature flag="my-feature" fallback={<Fallback />} loading={<Loading />}>
+  <EnabledContent />
+</Feature>
+```
+
+#### `<FeatureEnabled>`
+
+Render only when flag is enabled.
+
+```tsx
+<FeatureEnabled flag="my-feature">
+  <EnabledContent />
+</FeatureEnabled>
+```
+
+#### `<FeatureDisabled>`
+
+Render only when flag is disabled.
+
+```tsx
+<FeatureDisabled flag="my-feature">
+  <DisabledContent />
+</FeatureDisabled>
+```
+
+## Configuration
+
+### Environment Variables
+
+You can configure the SDK using environment variables:
+
+```bash
+SHIPOS_API_KEY=your-api-key
+SHIPOS_ENVIRONMENT=production
+SHIPOS_BASE_URL=https://api.shipos.app
+```
+
+### Server-Side Rendering (SSR)
+
+For SSR, you can pass initial flags to avoid loading states:
+
+```tsx
+// In your server component or getServerSideProps
+const shipos = createShipOS({ apiKey: process.env.SHIPOS_API_KEY });
+const initialFlags = await shipos.featureFlags.getAll();
+
+// Pass to provider
+<ShipOSProvider config={config} initialFlags={initialFlags}>
+  <App />
+</ShipOSProvider>
+```
+
+## License
+
+MIT

package/dist/cache.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Simple in-memory cache for SDK responses
+ */
+export declare class Cache {
+    private store;
+    private defaultTTL;
+    constructor(defaultTTL?: number);
+    /**
+     * Get a value from the cache
+     */
+    get<T>(key: string): T | null;
+    /**
+     * Set a value in the cache
+     */
+    set<T>(key: string, data: T): void;
+    /**
+     * Delete a value from the cache
+     */
+    delete(key: string): void;
+    /**
+     * Clear all cached values
+     */
+    clear(): void;
+    /**
+     * Update the default TTL
+     */
+    setTTL(ttl: number): void;
+}
+//# sourceMappingURL=cache.d.ts.map

package/dist/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,qBAAa,KAAK;IAChB,OAAO,CAAC,KAAK,CAA+C;IAC5D,OAAO,CAAC,UAAU,CAAS;gBAEf,UAAU,GAAE,MAAc;IAItC;;OAEG;IACH,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI;IAgB7B;;OAEG;IACH,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI;IAOlC;;OAEG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAIzB;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;CAG1B"}

package/dist/client.d.ts

@@ -0,0 +1,53 @@
+/**
+ * ShipOS SDK Client
+ *
+ * Main client for interacting with the ShipOS API.
+ * Methods are organized into namespaced modules:
+ * - `featureFlags` - Feature flag operations
+ * - `configs` - Global config operations
+ * - `customers` - Customer identification
+ */
+import { FeatureFlagsModule } from "./modules/feature-flags";
+import { ConfigsModule } from "./modules/configs";
+import { CustomersModule } from "./modules/customers";
+import type { ShipOSConfig } from "./types";
+export declare class ShipOS {
+    private apiKey;
+    private baseUrl;
+    private environment;
+    private cache;
+    private debug;
+    private customerId;
+    /** Feature flag operations */
+    readonly featureFlags: FeatureFlagsModule;
+    /** Global config operations */
+    readonly configs: ConfigsModule;
+    /** Customer identification */
+    readonly customers: CustomersModule;
+    constructor(config: ShipOSConfig);
+    /**
+     * Log debug messages
+     */
+    private log;
+    /**
+     * Make an authenticated request to the API
+     */
+    private request;
+    /**
+     * Clear the cache
+     */
+    clearCache(): void;
+    /**
+     * Update the environment
+     */
+    setEnvironment(environment: string): void;
+    /**
+     * Get current environment
+     */
+    getEnvironment(): string;
+}
+/**
+ * Create a new ShipOS client instance
+ */
+export declare function createShipOS(config: ShipOSConfig): ShipOS;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAY,MAAM,SAAS,CAAC;AAMtD,qBAAa,MAAM;IACjB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,KAAK,CAAU;IACvB,OAAO,CAAC,UAAU,CAAuB;IAEzC,8BAA8B;IAC9B,QAAQ,CAAC,YAAY,EAAE,kBAAkB,CAAC;IAC1C,+BAA+B;IAC/B,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAChC,8BAA8B;IAC9B,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;gBAExB,MAAM,EAAE,YAAY;IA2BhC;;OAEG;IACH,OAAO,CAAC,GAAG;IAMX;;OAEG;YACW,OAAO;IAsCrB;;OAEG;IACH,UAAU,IAAI,IAAI;IAKlB;;OAEG;IACH,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAMzC;;OAEG;IACH,cAAc,IAAI,MAAM;CAGzB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAEzD"}

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * ShipOS SDK
+ *
+ * Official SDK for ShipOS feature flags, global configs, and customer identification.
+ *
+ * @example
+ * ```typescript
+ * import { createShipOS } from '@shipos/sdk';
+ *
+ * const shipos = createShipOS({
+ *   apiKey: 'your-api-key',
+ *   environment: 'production',
+ * });
+ *
+ * // Identify a customer
+ * await shipos.customers.signIn({ externalId: 'user-123', metadata: { plan: 'pro' } });
+ *
+ * // Get all flags
+ * const flags = await shipos.featureFlags.getAll();
+ *
+ * // Get a single flag
+ * const isEnabled = await shipos.featureFlags.get('new-feature', false);
+ *
+ * // Get a config
+ * const pricing = await shipos.configs.get('pricing');
+ * ```
+ */
+export { ShipOS, createShipOS } from "./client";
+export { Cache } from "./cache";
+export type { ShipOSConfig, FlagsResponse, ConfigResponse, ApiError, CacheEntry, Result, CustomerInfo, SignInOptions, } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,YAAY,EACV,YAAY,EACZ,aAAa,EACb,cAAc,EACd,QAAQ,EACR,UAAU,EACV,MAAM,EACN,YAAY,EACZ,aAAa,GACd,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,214 @@
+// src/cache.ts
+class Cache {
+  store = new Map;
+  defaultTTL;
+  constructor(defaultTTL = 60000) {
+    this.defaultTTL = defaultTTL;
+  }
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry) {
+      return null;
+    }
+    if (Date.now() - entry.timestamp > this.defaultTTL) {
+      this.store.delete(key);
+      return null;
+    }
+    return entry.data;
+  }
+  set(key, data) {
+    this.store.set(key, {
+      data,
+      timestamp: Date.now()
+    });
+  }
+  delete(key) {
+    this.store.delete(key);
+  }
+  clear() {
+    this.store.clear();
+  }
+  setTTL(ttl) {
+    this.defaultTTL = ttl;
+  }
+}
+
+// src/modules/feature-flags.ts
+class FeatureFlagsModule {
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async getAll() {
+    const cacheKey = `flags:${this.ctx.getEnvironment()}`;
+    const cached = this.ctx.cache.get(cacheKey);
+    if (cached) {
+      this.ctx.log("Returning cached flags");
+      return cached;
+    }
+    const flags = await this.ctx.request("/v1/flags");
+    this.ctx.cache.set(cacheKey, flags);
+    return flags;
+  }
+  async get(key, defaultValue = false) {
+    const flags = await this.getAll();
+    return flags[key] ?? defaultValue;
+  }
+  async refresh() {
+    const cacheKey = `flags:${this.ctx.getEnvironment()}`;
+    this.ctx.cache.delete(cacheKey);
+    return this.getAll();
+  }
+}
+
+// src/modules/configs.ts
+class ConfigsModule {
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async get(slug) {
+    const cacheKey = `config:${this.ctx.getEnvironment()}:${slug}`;
+    const cached = this.ctx.cache.get(cacheKey);
+    if (cached) {
+      this.ctx.log(`Returning cached config: ${slug}`);
+      return cached;
+    }
+    const config = await this.ctx.request(`/v1/config/${slug}`);
+    this.ctx.cache.set(cacheKey, config);
+    return config;
+  }
+  async refresh(slug) {
+    const cacheKey = `config:${this.ctx.getEnvironment()}:${slug}`;
+    this.ctx.cache.delete(cacheKey);
+    return this.get(slug);
+  }
+}
+
+// src/modules/customers.ts
+class CustomersModule {
+  ctx;
+  customer = null;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async signIn(options) {
+    if (!options.externalId) {
+      throw new Error("ShipOS: externalId is required for signIn");
+    }
+    this.ctx.log(`Signing in customer: ${options.externalId}`);
+    this.customer = {
+      externalId: options.externalId,
+      metadata: options.metadata
+    };
+    this.ctx.setCustomerId(options.externalId);
+    await this.ctx.request("/v1/customers/identify", {
+      method: "POST",
+      body: {
+        externalId: options.externalId,
+        metadata: options.metadata ?? {}
+      }
+    });
+    this.ctx.log(`Customer signed in: ${options.externalId}`);
+    return this.customer;
+  }
+  signOut() {
+    this.ctx.log("Signing out customer");
+    this.customer = null;
+    this.ctx.setCustomerId(null);
+  }
+  get() {
+    return this.customer;
+  }
+}
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.shipos.app";
+var DEFAULT_CACHE_TTL = 60000;
+var SDK_VERSION = "0.1.0";
+
+class ShipOS {
+  apiKey;
+  baseUrl;
+  environment;
+  cache;
+  debug;
+  customerId = null;
+  featureFlags;
+  configs;
+  customers;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("ShipOS: apiKey is required");
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+    this.environment = config.environment || "production";
+    this.cache = new Cache(config.cacheTTL || DEFAULT_CACHE_TTL);
+    this.debug = config.debug || false;
+    const ctx = {
+      request: this.request.bind(this),
+      cache: this.cache,
+      getEnvironment: this.getEnvironment.bind(this),
+      log: this.log.bind(this),
+      setCustomerId: (id) => {
+        this.customerId = id;
+      }
+    };
+    this.featureFlags = new FeatureFlagsModule(ctx);
+    this.configs = new ConfigsModule(ctx);
+    this.customers = new CustomersModule(ctx);
+  }
+  log(...args) {
+    if (this.debug) {
+      console.log("[ShipOS]", ...args);
+    }
+  }
+  async request(endpoint, options = {}) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const method = options.method || "GET";
+    this.log(`${method} ${url}`);
+    const headers = {
+      "x-shipos-key": this.apiKey,
+      "x-shipos-env": this.environment,
+      "x-shipos-sdk-version": SDK_VERSION,
+      "Content-Type": "application/json"
+    };
+    if (this.customerId) {
+      headers["x-shipos-customer-id"] = this.customerId;
+    }
+    const fetchOptions = { method, headers };
+    if (options.body && method !== "GET") {
+      fetchOptions.body = JSON.stringify(options.body);
+    }
+    const response = await fetch(url, fetchOptions);
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({
+        error: `HTTP ${response.status}`,
+        code: "HTTP_ERROR"
+      }));
+      throw new Error(error.error || `Request failed: ${response.status}`);
+    }
+    return response.json();
+  }
+  clearCache() {
+    this.cache.clear();
+    this.log("Cache cleared");
+  }
+  setEnvironment(environment) {
+    this.environment = environment;
+    this.cache.clear();
+    this.log(`Environment changed to: ${environment}`);
+  }
+  getEnvironment() {
+    return this.environment;
+  }
+}
+function createShipOS(config) {
+  return new ShipOS(config);
+}
+export {
+  createShipOS,
+  ShipOS,
+  Cache
+};

package/dist/modules/configs.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Configs Module
+ *
+ * Provides namespaced access to global configuration operations.
+ *
+ * @example
+ * ```typescript
+ * const pricing = await shipos.configs.get<PricingConfig>('pricing');
+ * ```
+ */
+import type { Cache } from "../cache";
+import type { ConfigResponse } from "../types";
+/**
+ * Internal context shared by the parent ShipOS client
+ */
+export interface ConfigsContext {
+    request: <T>(endpoint: string, options?: {
+        method?: string;
+        body?: unknown;
+    }) => Promise<T>;
+    cache: Cache;
+    getEnvironment: () => string;
+    log: (...args: unknown[]) => void;
+}
+export declare class ConfigsModule {
+    private ctx;
+    constructor(ctx: ConfigsContext);
+    /**
+     * Get a configuration by slug
+     *
+     * @param slug - The config slug
+     * @returns The config data
+     *
+     * @example
+     * ```typescript
+     * interface PricingConfig {
+     *   plans: Array<{ name: string; price: number }>;
+     * }
+     * const pricing = await shipos.configs.get<PricingConfig>('pricing');
+     * ```
+     */
+    get<T = Record<string, unknown>>(slug: string): Promise<ConfigResponse<T>>;
+    /**
+     * Refresh a config (bypass cache)
+     *
+     * @param slug - The config slug
+     * @returns Fresh config from the API
+     *
+     * @example
+     * ```typescript
+     * const freshConfig = await shipos.configs.refresh<PricingConfig>('pricing');
+     * ```
+     */
+    refresh<T = Record<string, unknown>>(slug: string): Promise<ConfigResponse<T>>;
+}
+//# sourceMappingURL=configs.d.ts.map

package/dist/modules/configs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configs.d.ts","sourceRoot":"","sources":["../../src/modules/configs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;IAC5F,KAAK,EAAE,KAAK,CAAC;IACb,cAAc,EAAE,MAAM,MAAM,CAAC;IAC7B,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;CACnC;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,GAAG,CAAiB;gBAEhB,GAAG,EAAE,cAAc;IAI/B;;;;;;;;;;;;;OAaG;IACG,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAchF;;;;;;;;;;OAUG;IACG,OAAO,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;CAKrF"}

package/dist/modules/customers.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Customers Module
+ *
+ * Provides customer identification (sign-in) for the ShipOS SDK.
+ * When a customer is signed in, their external ID is sent with
+ * subsequent API requests for targeting and analytics.
+ *
+ * @example
+ * ```typescript
+ * await shipos.customers.signIn({ externalId: 'user-123', metadata: { plan: 'pro' } });
+ * const customer = shipos.customers.get();
+ * shipos.customers.signOut();
+ * ```
+ */
+import type { CustomerInfo, SignInOptions } from "../types";
+/**
+ * Internal context shared by the parent ShipOS client
+ */
+export interface CustomersContext {
+    request: <T>(endpoint: string, options?: {
+        method?: string;
+        body?: unknown;
+    }) => Promise<T>;
+    log: (...args: unknown[]) => void;
+    setCustomerId: (id: string | null) => void;
+}
+export declare class CustomersModule {
+    private ctx;
+    private customer;
+    constructor(ctx: CustomersContext);
+    /**
+     * Sign in a customer
+     *
+     * Identifies the customer by their external ID and optional metadata.
+     * The customer context is stored locally and sent to the API for
+     * tracking and future flag targeting.
+     *
+     * @param options - Sign-in options with externalId and optional metadata
+     *
+     * @example
+     * ```typescript
+     * await shipos.customers.signIn({
+     *   externalId: 'user-123',
+     *   metadata: { name: 'John', plan: 'pro' },
+     * });
+     * ```
+     */
+    signIn(options: SignInOptions): Promise<CustomerInfo>;
+    /**
+     * Sign out the current customer
+     *
+     * Clears the local customer context. Subsequent API requests
+     * will no longer include customer identification.
+     *
+     * @example
+     * ```typescript
+     * shipos.customers.signOut();
+     * ```
+     */
+    signOut(): void;
+    /**
+     * Get the current signed-in customer
+     *
+     * @returns The current customer info, or null if no customer is signed in
+     *
+     * @example
+     * ```typescript
+     * const customer = shipos.customers.get();
+     * if (customer) {
+     *   console.log(`Signed in as: ${customer.externalId}`);
+     * }
+     * ```
+     */
+    get(): CustomerInfo | null;
+}
+//# sourceMappingURL=customers.d.ts.map

package/dist/modules/customers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customers.d.ts","sourceRoot":"","sources":["../../src/modules/customers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;IAC5F,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;IAClC,aAAa,EAAE,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;CAC5C;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,GAAG,CAAmB;IAC9B,OAAO,CAAC,QAAQ,CAA6B;gBAEjC,GAAG,EAAE,gBAAgB;IAIjC;;;;;;;;;;;;;;;;OAgBG;IACG,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IA6B3D;;;;;;;;;;OAUG;IACH,OAAO,IAAI,IAAI;IAMf;;;;;;;;;;;;OAYG;IACH,GAAG,IAAI,YAAY,GAAG,IAAI;CAG3B"}