@schematichq/schematic-vue 0.1.0

package/dist/schematic-vue.d.ts

@@ -0,0 +1,239 @@
+import { App } from 'vue';
+import { CheckFlagReturn } from '@schematichq/schematic-js';
+import { ComputedRef } from 'vue';
+import { Event as Event_2 } from '@schematichq/schematic-js';
+import { EventBody } from '@schematichq/schematic-js';
+import { EventBodyIdentify } from '@schematichq/schematic-js';
+import { EventBodyTrack } from '@schematichq/schematic-js';
+import { EventType } from '@schematichq/schematic-js';
+import { Keys } from '@schematichq/schematic-js';
+import { Ref } from 'vue';
+import { RuleType } from '@schematichq/schematic-js';
+import { Schematic } from '@schematichq/schematic-js';
+import { SchematicContext } from '@schematichq/schematic-js';
+import * as SchematicJS from '@schematichq/schematic-js';
+import { SchematicOptions } from '@schematichq/schematic-js';
+import { StoragePersister } from '@schematichq/schematic-js';
+import { Traits } from '@schematichq/schematic-js';
+import { UsagePeriod } from '@schematichq/schematic-js';
+
+declare type BaseSchematicPluginOptions = Omit<SchematicJS.SchematicOptions, "client" | "publishableKey">;
+
+export { CheckFlagReturn }
+
+export { Event_2 as Event }
+
+export { EventBody }
+
+export { EventBodyIdentify }
+
+export { EventBodyTrack }
+
+export { EventType }
+
+export { Keys }
+
+export { RuleType }
+
+export { Schematic }
+
+export declare interface SchematicComposableOpts {
+    client?: SchematicJS.Schematic;
+}
+
+export { SchematicContext }
+
+export declare interface SchematicContextValue {
+    client: SchematicJS.Schematic;
+}
+
+export { SchematicOptions }
+
+/**
+ * Vue plugin for Schematic
+ * Install this plugin to make Schematic available throughout your Vue app
+ *
+ * @example
+ * ```typescript
+ * import { createApp } from 'vue'
+ * import { SchematicPlugin } from '@schematichq/schematic-vue'
+ *
+ * const app = createApp(App)
+ * app.use(SchematicPlugin, { publishableKey: 'your-publishable-key' })
+ * ```
+ */
+export declare const SchematicPlugin: {
+    install(app: App, options: SchematicPluginOptions): void;
+};
+
+export declare type SchematicPluginOptions = SchematicPluginOptionsWithClient | SchematicPluginOptionsWithPublishableKey;
+
+declare type SchematicPluginOptionsWithClient = BaseSchematicPluginOptions & {
+    client: SchematicJS.Schematic;
+    publishableKey?: never;
+};
+
+declare type SchematicPluginOptionsWithPublishableKey = BaseSchematicPluginOptions & {
+    client?: never;
+    publishableKey: string;
+};
+
+export { StoragePersister }
+
+export { Traits }
+
+export { UsagePeriod }
+
+/**
+ * Access the Schematic client instance
+ * Must be called within a component that has SchematicPlugin installed
+ *
+ * @throws Error if called outside of a component with SchematicPlugin
+ */
+export declare const useSchematic: () => SchematicContextValue;
+
+/**
+ * Get the Schematic client instance
+ * Can optionally override with a custom client
+ */
+export declare const useSchematicClient: (opts?: SchematicComposableOpts) => SchematicJS.Schematic;
+
+/**
+ * Access context management methods
+ * Provides setContext method to update user/company context
+ *
+ * @example
+ * ```typescript
+ * const { setContext } = useSchematicContext()
+ * setContext({
+ *   user: { id: 'user-123' },
+ *   company: { id: 'company-456' }
+ * })
+ * ```
+ */
+export declare const useSchematicContext: (opts?: SchematicComposableOpts) => {
+    setContext: (context: SchematicJS.SchematicContext) => Promise<void>;
+};
+
+/**
+ * Check feature entitlement with usage details
+ * Returns reactive refs for flag value, usage, allocation, and exceeded status
+ *
+ * @param key - The flag/feature key to check
+ * @param opts - Optional configuration including fallback value
+ * @returns Object with reactive refs for entitlement data
+ *
+ * @example
+ * ```typescript
+ * const {
+ *   value: isEnabled,
+ *   featureUsage,
+ *   featureAllocation,
+ *   featureUsageExceeded
+ * } = useSchematicEntitlement('my-feature-key')
+ *
+ * // In template
+ * <div v-if="featureUsageExceeded">
+ *   Usage limit reached: {{ featureUsage }} / {{ featureAllocation }}
+ * </div>
+ * ```
+ */
+export declare const useSchematicEntitlement: (key: string, opts?: UseSchematicFlagOpts) => {
+    check: ComputedRef<    {
+    featureUsageExceeded?: boolean | undefined;
+    companyId?: string | undefined;
+    error?: string | undefined;
+    featureAllocation?: number | undefined;
+    featureUsage?: number | undefined;
+    featureUsageEvent?: string | undefined;
+    featureUsagePeriod?: SchematicJS.UsagePeriod | undefined;
+    featureUsageResetAt?: Date | undefined;
+    flag: string;
+    flagId?: string | undefined;
+    reason: string;
+    ruleId?: string | undefined;
+    ruleType?: SchematicJS.RuleType | undefined;
+    userId?: string | undefined;
+    value: boolean;
+    }>;
+    value: ComputedRef<boolean>;
+    flag: ComputedRef<string>;
+    reason: ComputedRef<string>;
+    featureUsage: ComputedRef<number | undefined>;
+    featureAllocation: ComputedRef<number | undefined>;
+    featureUsageExceeded: ComputedRef<boolean | undefined>;
+    featureUsageEvent: ComputedRef<string | undefined>;
+    featureUsagePeriod: ComputedRef<SchematicJS.UsagePeriod | undefined>;
+    flagId: ComputedRef<string | undefined>;
+    ruleId: ComputedRef<string | undefined>;
+    companyId: ComputedRef<string | undefined>;
+    userId: ComputedRef<string | undefined>;
+};
+
+/**
+ * Access event tracking methods
+ * Provides identify and track methods for user identification and event tracking
+ *
+ * @example
+ * ```typescript
+ * const { identify, track } = useSchematicEvents()
+ *
+ * // Identify a user and company
+ * identify({
+ *   keys: { id: 'user-123' },
+ *   company: {
+ *     keys: { id: 'company-456' },
+ *     traits: { plan: 'enterprise' }
+ *   }
+ * })
+ *
+ * // Track an event
+ * track({ event: 'query' })
+ * track({ event: 'query', quantity: 10 })
+ * ```
+ */
+export declare const useSchematicEvents: (opts?: SchematicComposableOpts) => {
+    track: (body: SchematicJS.EventBodyTrack) => Promise<void>;
+    identify: (body: SchematicJS.EventBodyIdentify) => void;
+};
+
+/**
+ * Check a feature flag value
+ * Returns a reactive ref that updates when the flag value changes
+ *
+ * @param key - The flag key to check
+ * @param opts - Optional configuration including fallback value
+ * @returns Ref<boolean> - Reactive boolean value of the flag
+ *
+ * @example
+ * ```typescript
+ * const isFeatureEnabled = useSchematicFlag('my-flag-key')
+ *
+ * // In template
+ * <div v-if="isFeatureEnabled">Feature content</div>
+ * ```
+ */
+export declare const useSchematicFlag: (key: string, opts?: UseSchematicFlagOpts) => Ref<boolean>;
+
+export declare type UseSchematicFlagOpts = SchematicComposableOpts & {
+    fallback?: boolean;
+};
+
+/**
+ * Check if Schematic data is still loading
+ * Returns a reactive ref that is true while initial flag data is being fetched
+ *
+ * Useful for showing loading states before displaying flag checks
+ *
+ * @example
+ * ```typescript
+ * const isPending = useSchematicIsPending()
+ *
+ * // In template
+ * <div v-if="isPending">Loading...</div>
+ * <div v-else-if="isFeatureEnabled">Feature content</div>
+ * ```
+ */
+export declare const useSchematicIsPending: (opts?: SchematicComposableOpts) => Ref<boolean>;
+
+export { }