@burdenoff/be-sdk 2026.1015.2 → 2026.1017.1

package/dist/index-DfYu1p9e.d.ts

@@ -0,0 +1,530 @@
+interface RetryConfig {
+    attempts?: number;
+    initialDelayMs?: number;
+    maxDelayMs?: number;
+    retryOn?: (status: number) => boolean;
+}
+interface BreakerConfig {
+    threshold?: number;
+    cooldownMs?: number;
+}
+interface HttpClientConfig {
+    baseUrl?: string;
+    defaultTimeoutMs?: number;
+    retry?: RetryConfig;
+    breaker?: BreakerConfig;
+    defaultHeaders?: Record<string, string>;
+}
+declare class CircuitBreakerOpenError extends Error {
+    constructor(host: string);
+}
+interface HttpClientInit extends RequestInit {
+    timeoutMs?: number;
+    retry?: RetryConfig;
+}
+declare function __resetHttpClientBreakers(): void;
+declare function httpClient(url: string, init?: HttpClientInit, config?: HttpClientConfig): Promise<Response>;
+declare function createHttpClient(config?: HttpClientConfig): (url: string, init?: HttpClientInit) => Promise<Response>;
+
+interface LeaderLockRedis {
+    set(key: string, value: string, ex: 'EX', seconds: number, nx: 'NX'): Promise<'OK' | null>;
+    eval(script: string, numKeys: number, ...args: string[]): Promise<unknown>;
+}
+interface LeaderLockOptions {
+    ttlMs: number;
+    renewMs?: number;
+}
+interface LeaderLockResult<T> {
+    acquired: boolean;
+    result?: T;
+}
+declare function normalizeRedisUrl(url: string): string;
+declare function withLeaderLock<T>(redis: LeaderLockRedis, name: string, fn: () => Promise<T>, options: LeaderLockOptions): Promise<LeaderLockResult<T>>;
+interface CreateLeaderLeaseOptions {
+    name: string;
+    ttlMs: number;
+    redis: LeaderLockRedis;
+    renewMs?: number;
+}
+interface LeaderLease {
+    renew(): Promise<boolean>;
+    release(): Promise<void>;
+    isHeld(): boolean;
+}
+declare function createLeaderLease(options: CreateLeaderLeaseOptions): LeaderLease;
+
+interface RateLimitRedis {
+    incr(key: string): Promise<number>;
+    pexpire(key: string, ms: number): Promise<number | 'OK'>;
+    pttl(key: string): Promise<number>;
+}
+interface RateLimitInput {
+    key: string;
+    limit: number;
+    windowMs: number;
+}
+interface RateLimitResult {
+    allowed: boolean;
+    count: number;
+    remaining: number;
+    resetAt: number;
+}
+declare function rateLimitIncr(redis: RateLimitRedis, input: RateLimitInput): Promise<RateLimitResult>;
+
+interface ClampLimitOptions {
+    defaultLimit?: number;
+    maxLimit?: number;
+    minLimit?: number;
+}
+declare const DEFAULT_GRAPHQL_PAGE_LIMIT = 50;
+declare const MAX_GRAPHQL_PAGE_LIMIT = 100;
+declare function clampLimit(input: number | undefined | null, opts?: ClampLimitOptions): number;
+declare function clampOffset(input: number | undefined | null): number;
+declare function clampGraphqlLimit(input: number | undefined | null, opts?: ClampLimitOptions): number;
+interface OffsetPaginationInput {
+    limit?: number | null;
+    offset?: number | null;
+}
+interface NormalizedOffsetPagination {
+    limit: number;
+    offset: number;
+}
+declare function normalizeOffsetPagination(input: OffsetPaginationInput | null | undefined, opts?: ClampLimitOptions): NormalizedOffsetPagination;
+interface CursorPaginationInput {
+    first?: number | null;
+    after?: string | null;
+}
+interface NormalizedCursorPagination {
+    first: number;
+    after: string | null;
+    take: number;
+}
+declare function normalizeCursorPagination(input: CursorPaginationInput | null | undefined, opts?: ClampLimitOptions): NormalizedCursorPagination;
+type CursorPayloadValue = string | number | boolean | null;
+type CursorPayload = Record<string, CursorPayloadValue>;
+declare function encodeCursor(payload: CursorPayload): string;
+declare function decodeCursor(cursor: string | null | undefined): CursorPayload | null;
+interface PageInfo {
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    startCursor: string | null;
+    endCursor: string | null;
+}
+interface ConnectionEdge<TItem> {
+    node: TItem;
+    cursor: string;
+}
+interface ConnectionResult<TItem> {
+    edges: ConnectionEdge<TItem>[];
+    nodes: TItem[];
+    pageInfo: PageInfo;
+    totalCount?: number | null;
+}
+interface BuildConnectionOptions<TItem> {
+    limit: number;
+    cursorForNode: (item: TItem) => string;
+    hasPreviousPage?: boolean;
+    totalCount?: number | null;
+}
+declare function buildConnection<TItem>(items: TItem[], opts: BuildConnectionOptions<TItem>): ConnectionResult<TItem>;
+interface OffsetPageResult<TItem> {
+    items: TItem[];
+    total: number;
+    limit: number;
+    offset: number;
+    hasMore: boolean;
+    nextOffset: number | null;
+}
+declare function buildOffsetPage<TItem>(items: TItem[], total: number, pagination: NormalizedOffsetPagination): OffsetPageResult<TItem>;
+declare function toPrismaPage(pagination: NormalizedOffsetPagination): {
+    take: number;
+    skip: number;
+};
+interface PaginateInput<TWhere, TOrderBy> {
+    take?: number | null;
+    cursor?: string | null;
+    where?: TWhere;
+    orderBy?: TOrderBy;
+}
+interface PaginateResult<TItem> {
+    items: TItem[];
+    hasMore: boolean;
+    nextCursor: string | null;
+}
+interface PrismaModelLike<TItem, TWhere, TOrderBy> {
+    findMany(args: {
+        take?: number;
+        skip?: number;
+        cursor?: {
+            id: string;
+        };
+        where?: TWhere;
+        orderBy?: TOrderBy;
+    }): Promise<TItem[]>;
+}
+declare function paginate<TItem extends {
+    id: string;
+}, TWhere = unknown, TOrderBy = unknown>(model: PrismaModelLike<TItem, TWhere, TOrderBy>, input: PaginateInput<TWhere, TOrderBy>, opts?: ClampLimitOptions): Promise<PaginateResult<TItem>>;
+
+interface DataLoaderLike<K, V> {
+    load(key: K): Promise<V>;
+    loadMany(keys: readonly K[]): Promise<(V | Error)[]>;
+    clear(key: K): this;
+    clearAll(): this;
+    prime(key: K, value: V): this;
+}
+type LoaderMap = Record<string, DataLoaderLike<unknown, unknown>>;
+type LoaderBuilder<Ctx, M extends LoaderMap> = (ctx: Ctx) => M;
+declare function buildLoaders<Ctx, M extends LoaderMap>(ctx: Ctx, builder: LoaderBuilder<Ctx, M>): M;
+interface ReferenceObject {
+    id?: string;
+    [key: string]: unknown;
+}
+declare function resolveReferenceLoader<T, Ctx extends {
+    loaders: LoaderMap;
+}>(loaderName: string, keyField?: string): (reference: ReferenceObject, ctx: Ctx) => Promise<T | null>;
+
+interface CacheVersionRedis {
+    get(key: string): Promise<string | null>;
+    incr(key: string): Promise<number>;
+}
+declare function getNamespaceVersion(redis: CacheVersionRedis, namespace: string): Promise<number>;
+declare function buildCacheKey(redis: CacheVersionRedis, namespace: string, ...parts: string[]): Promise<string>;
+declare function invalidateNamespace(redis: CacheVersionRedis, namespace: string): Promise<number>;
+
+interface PrismaRawClient {
+    $executeRawUnsafe(query: string, ...values: unknown[]): Promise<unknown>;
+    $queryRawUnsafe<T = unknown>(query: string, ...values: unknown[]): Promise<T>;
+}
+declare function monthlyPartitionName(table: string, year: number, month: number): string;
+interface EnsureMonthlyOptions {
+    table: string;
+    from: Date;
+    to: Date;
+}
+declare function ensureMonthlyPartitions(prisma: PrismaRawClient, opts: EnsureMonthlyOptions): Promise<string[]>;
+interface DropOldOptions {
+    table: string;
+    beforeDate: Date;
+}
+declare function dropOldPartitions(prisma: PrismaRawClient, opts: DropOldOptions): Promise<string[]>;
+
+interface LLMRequest {
+    model?: string;
+    messages: Array<{
+        role: 'system' | 'user' | 'assistant';
+        content: string;
+    }>;
+    maxTokens?: number;
+    temperature?: number;
+    stream?: boolean;
+    timeoutMs?: number;
+}
+interface LLMResponse {
+    provider: string;
+    content: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    raw?: unknown;
+}
+interface LLMProviderAdapter {
+    name: string;
+    complete(req: LLMRequest, signal: AbortSignal): Promise<LLMResponse>;
+}
+interface LLMRouterOptions {
+    timeoutMs?: number;
+    maxAttempts?: number;
+    initialDelayMs?: number;
+    maxOutputTokensCap?: number;
+}
+declare class LLMRouter {
+    private readonly adapters;
+    private readonly opts;
+    constructor(opts?: LLMRouterOptions);
+    register(adapter: LLMProviderAdapter): void;
+    private resolveChain;
+    complete(req: LLMRequest): Promise<LLMResponse>;
+}
+
+interface InvocationIdentity {
+    readonly workspaceId: string;
+    readonly actorId: string;
+    readonly actorType: 'user' | 'app' | 'service' | 'super_admin';
+    readonly onBehalfOf: string | null;
+}
+interface InvocationAttemptInput {
+    readonly attemptKey: string;
+    readonly operationKey: string;
+    readonly productKey: string;
+    readonly providerKey: string;
+    readonly modelKey: string;
+    readonly startedAt: string;
+}
+interface InvocationUsageInput {
+    readonly attemptKey: string;
+    readonly eventKey: string;
+    readonly revision: number;
+    readonly predecessorId: string | null;
+    readonly outcome: 'succeeded' | 'failed' | 'blocked' | 'timed_out';
+    readonly inputTokens: string | null;
+    readonly outputTokens: string | null;
+    readonly cachedInputTokens: string | null;
+    readonly costMicroUsd: null;
+    readonly finishedAt: string;
+}
+interface InvocationUsageReceipt extends Omit<InvocationUsageInput, 'attemptKey' | 'costMicroUsd'> {
+    readonly id: string;
+    readonly attemptId: string;
+    readonly fingerprint: string;
+    readonly totalTokens: string | null;
+    readonly costMicroUsd: string | null;
+    readonly pricingReference: string | null;
+    readonly origin: 'CALLER_REPORTED';
+    readonly currency: 'USD';
+    readonly costKind: 'ESTIMATE';
+    readonly createdAt: string;
+}
+interface InvocationAttemptReceipt extends InvocationAttemptInput {
+    readonly id: string;
+    readonly workspaceId: string;
+    readonly createdBy: string;
+    readonly origin: 'CALLER_REPORTED';
+    readonly fingerprint: string;
+    readonly createdAt: string;
+    readonly revisions: readonly InvocationUsageReceipt[];
+    readonly hasMoreRevisions: boolean;
+}
+type InvocationReceipt = InvocationAttemptReceipt | InvocationUsageReceipt;
+type InvocationIntent = {
+    readonly identity: InvocationIdentity;
+    readonly key: string;
+} & ({
+    readonly kind: 'begin';
+    readonly input: InvocationAttemptInput;
+} | {
+    readonly kind: 'record';
+    readonly input: InvocationUsageInput;
+    readonly attempt: InvocationAttemptInput;
+    readonly attemptId: string;
+});
+interface InvocationDelivery {
+    readonly intent: InvocationIntent;
+    readonly version: number;
+    readonly state: 'UNSENT' | 'DISPATCHED' | 'UNKNOWN' | 'ACKNOWLEDGED';
+    readonly receipt: InvocationReceipt | null;
+    readonly observedIds: readonly string[];
+}
+interface InvocationDeliveryStore {
+    load(identity: InvocationIdentity, key: string): Promise<InvocationDelivery | null>;
+    create(value: InvocationDelivery): Promise<boolean>;
+    compareAndSet(previous: InvocationDelivery, next: InvocationDelivery): Promise<boolean>;
+}
+interface InvocationCallerAdmission {
+    readonly identity: InvocationIdentity;
+    readonly expiresAt: number;
+}
+interface InvocationAccountingOptions {
+    readonly store: InvocationDeliveryStore;
+    readonly transport: (document: string, variables: Readonly<Record<string, unknown>>) => Promise<unknown>;
+    readonly admit: () => Promise<InvocationCallerAdmission | null>;
+    readonly now?: () => number;
+}
+type InvocationDeliveryResult = {
+    readonly status: 'ACKNOWLEDGED';
+    readonly receipt: InvocationReceipt;
+    readonly observedIds: readonly string[];
+} | {
+    readonly status: 'HOLD';
+    readonly reason: 'CONTEXT' | 'STORE' | 'OCCUPIED' | 'UNKNOWN' | 'RECEIPT' | 'HISTORY';
+    readonly observedIds: readonly string[];
+    readonly knownReceipt?: InvocationReceipt;
+};
+
+declare function validateInvocationDelivery(value: unknown): InvocationDelivery;
+declare class InvocationAccountingCoordinator {
+    private readonly options;
+    private readonly now;
+    constructor(options: InvocationAccountingOptions);
+    private admitted;
+    private load;
+    private unknown;
+    private acknowledge;
+    private deliver;
+    begin(identity: InvocationIdentity, key: string, input: InvocationAttemptInput): Promise<InvocationDeliveryResult>;
+    record(identity: InvocationIdentity, key: string, beginKey: string, input: InvocationUsageInput, predecessorKey?: string | null): Promise<InvocationDeliveryResult>;
+    reconcile(identity: InvocationIdentity, key: string): Promise<InvocationDeliveryResult>;
+}
+
+declare const PROMPTS_V2_DOCUMENTS: Readonly<{
+    begin: "mutation SdkBeginInvocationAttemptV2($input:PromptBeginInvocationAttemptV2Input!){promptBeginInvocationAttemptV2(input:$input){id workspaceId attemptKey operationKey productKey providerKey modelKey startedAt createdBy origin fingerprint createdAt revisions{id attemptId revision predecessorId eventKey fingerprint outcome inputTokens outputTokens totalTokens cachedInputTokens costMicroUsd currency costKind pricingReference origin finishedAt createdAt} hasMoreRevisions}}";
+    record: "mutation SdkRecordInvocationUsageV2($input:PromptRecordInvocationUsageV2Input!){promptRecordInvocationUsageV2(input:$input){id attemptId revision predecessorId eventKey fingerprint outcome inputTokens outputTokens totalTokens cachedInputTokens costMicroUsd currency costKind pricingReference origin finishedAt createdAt}}";
+    read: "query SdkInvocationAttemptV2($key:String!,$offset:Int){promptInvocationAttemptV2(attemptKey:$key,revisionOffset:$offset){id workspaceId attemptKey operationKey productKey providerKey modelKey startedAt createdBy origin fingerprint createdAt revisions{id attemptId revision predecessorId eventKey fingerprint outcome inputTokens outputTokens totalTokens cachedInputTokens costMicroUsd currency costKind pricingReference origin finishedAt createdAt} hasMoreRevisions}}";
+    summary: "query SdkUsageSummaryV2($from:DateTime!,$to:DateTime!,$product:String,$operation:String){promptUsageSummaryV2(from:$from,to:$to,productKey:$product,operationKey:$operation){workspaceId from to scope productKey operationKey origin currency costKind operations attempts pendingAttempts knownAttempts partialAttempts unknownAttempts inputTokens{knownSubtotal knownAttempts missingAttempts} outputTokens{knownSubtotal knownAttempts missingAttempts} totalTokens{knownSubtotal knownAttempts missingAttempts} costMicroUsd{knownSubtotal knownAttempts missingAttempts}}}";
+}>;
+
+type UsageIssue = 'INPUT' | 'OUTPUT' | 'CACHE_READ' | 'CACHE_WRITE' | 'CACHE_SUBSET' | 'INPUT_OVERFLOW' | 'CUMULATIVE_REGRESSION';
+interface NormalizedInvocationUsage {
+    readonly inputTokens: string | null;
+    readonly outputTokens: string | null;
+    readonly cachedInputTokens: string | null;
+    readonly costMicroUsd: null;
+    readonly reportedModel: string | null;
+    readonly issues: readonly UsageIssue[];
+}
+interface NormalizedClaudeUsage extends NormalizedInvocationUsage {
+    readonly uncachedInputTokens: string | null;
+    readonly cacheCreationInputTokens: string | null;
+    readonly cacheReadInputTokens: string | null;
+}
+declare function normalizeOpenAIUsage(response: unknown): NormalizedInvocationUsage;
+declare function normalizeClaudeUsage(response: unknown): NormalizedClaudeUsage;
+declare function createClaudeUsageAccumulator(): (snapshot: unknown) => NormalizedClaudeUsage;
+
+declare class InvocationAccountingValidationError extends Error {
+    constructor();
+}
+declare function validateInvocationIdentity(value: unknown): InvocationIdentity;
+declare function validateInvocationAttemptInput(value: unknown): InvocationAttemptInput;
+declare function validateInvocationUsageInput(value: unknown): InvocationUsageInput;
+declare function validateInvocationUsageReceipt(value: unknown, expected: InvocationUsageInput, attemptId: string): InvocationUsageReceipt;
+declare function validateInvocationAttemptReceipt(value: unknown, expected: InvocationAttemptInput, identity: InvocationIdentity): InvocationAttemptReceipt;
+
+interface InvocationSummarySelection {
+    readonly workspaceId: string;
+    readonly from: string;
+    readonly to: string;
+    readonly productKey: string | null;
+    readonly operationKey: string | null;
+}
+interface InvocationSummaryComponent {
+    readonly knownSubtotal: string | null;
+    readonly knownAttempts: string;
+    readonly missingAttempts: string;
+}
+interface InvocationUsageSummary extends InvocationSummarySelection {
+    readonly scope: 'RECORDED_V2_ATTEMPTS';
+    readonly origin: 'CALLER_REPORTED';
+    readonly currency: 'USD';
+    readonly costKind: 'ESTIMATE';
+    readonly attempts: string;
+    readonly operations: string;
+    readonly pendingAttempts: string;
+    readonly knownAttempts: string;
+    readonly partialAttempts: string;
+    readonly unknownAttempts: string;
+    readonly inputTokens: InvocationSummaryComponent;
+    readonly outputTokens: InvocationSummaryComponent;
+    readonly totalTokens: InvocationSummaryComponent;
+    readonly costMicroUsd: InvocationSummaryComponent;
+}
+declare function validateInvocationUsageSummary(value: unknown, selection: InvocationSummarySelection): InvocationUsageSummary;
+
+type index_BreakerConfig = BreakerConfig;
+type index_BuildConnectionOptions<TItem> = BuildConnectionOptions<TItem>;
+type index_CacheVersionRedis = CacheVersionRedis;
+type index_CircuitBreakerOpenError = CircuitBreakerOpenError;
+declare const index_CircuitBreakerOpenError: typeof CircuitBreakerOpenError;
+type index_ClampLimitOptions = ClampLimitOptions;
+type index_ConnectionEdge<TItem> = ConnectionEdge<TItem>;
+type index_ConnectionResult<TItem> = ConnectionResult<TItem>;
+type index_CreateLeaderLeaseOptions = CreateLeaderLeaseOptions;
+type index_CursorPaginationInput = CursorPaginationInput;
+type index_CursorPayload = CursorPayload;
+type index_CursorPayloadValue = CursorPayloadValue;
+declare const index_DEFAULT_GRAPHQL_PAGE_LIMIT: typeof DEFAULT_GRAPHQL_PAGE_LIMIT;
+type index_DataLoaderLike<K, V> = DataLoaderLike<K, V>;
+type index_DropOldOptions = DropOldOptions;
+type index_EnsureMonthlyOptions = EnsureMonthlyOptions;
+type index_HttpClientConfig = HttpClientConfig;
+type index_HttpClientInit = HttpClientInit;
+type index_InvocationAccountingCoordinator = InvocationAccountingCoordinator;
+declare const index_InvocationAccountingCoordinator: typeof InvocationAccountingCoordinator;
+type index_InvocationAccountingOptions = InvocationAccountingOptions;
+type index_InvocationAccountingValidationError = InvocationAccountingValidationError;
+declare const index_InvocationAccountingValidationError: typeof InvocationAccountingValidationError;
+type index_InvocationAttemptInput = InvocationAttemptInput;
+type index_InvocationAttemptReceipt = InvocationAttemptReceipt;
+type index_InvocationCallerAdmission = InvocationCallerAdmission;
+type index_InvocationDelivery = InvocationDelivery;
+type index_InvocationDeliveryResult = InvocationDeliveryResult;
+type index_InvocationDeliveryStore = InvocationDeliveryStore;
+type index_InvocationIdentity = InvocationIdentity;
+type index_InvocationIntent = InvocationIntent;
+type index_InvocationReceipt = InvocationReceipt;
+type index_InvocationSummaryComponent = InvocationSummaryComponent;
+type index_InvocationSummarySelection = InvocationSummarySelection;
+type index_InvocationUsageInput = InvocationUsageInput;
+type index_InvocationUsageReceipt = InvocationUsageReceipt;
+type index_InvocationUsageSummary = InvocationUsageSummary;
+type index_LLMProviderAdapter = LLMProviderAdapter;
+type index_LLMRequest = LLMRequest;
+type index_LLMResponse = LLMResponse;
+type index_LLMRouter = LLMRouter;
+declare const index_LLMRouter: typeof LLMRouter;
+type index_LLMRouterOptions = LLMRouterOptions;
+type index_LeaderLease = LeaderLease;
+type index_LeaderLockOptions = LeaderLockOptions;
+type index_LeaderLockRedis = LeaderLockRedis;
+type index_LeaderLockResult<T> = LeaderLockResult<T>;
+type index_LoaderBuilder<Ctx, M extends LoaderMap> = LoaderBuilder<Ctx, M>;
+type index_LoaderMap = LoaderMap;
+declare const index_MAX_GRAPHQL_PAGE_LIMIT: typeof MAX_GRAPHQL_PAGE_LIMIT;
+type index_NormalizedClaudeUsage = NormalizedClaudeUsage;
+type index_NormalizedCursorPagination = NormalizedCursorPagination;
+type index_NormalizedInvocationUsage = NormalizedInvocationUsage;
+type index_NormalizedOffsetPagination = NormalizedOffsetPagination;
+type index_OffsetPageResult<TItem> = OffsetPageResult<TItem>;
+type index_OffsetPaginationInput = OffsetPaginationInput;
+declare const index_PROMPTS_V2_DOCUMENTS: typeof PROMPTS_V2_DOCUMENTS;
+type index_PageInfo = PageInfo;
+type index_PaginateInput<TWhere, TOrderBy> = PaginateInput<TWhere, TOrderBy>;
+type index_PaginateResult<TItem> = PaginateResult<TItem>;
+type index_PrismaModelLike<TItem, TWhere, TOrderBy> = PrismaModelLike<TItem, TWhere, TOrderBy>;
+type index_PrismaRawClient = PrismaRawClient;
+type index_RateLimitInput = RateLimitInput;
+type index_RateLimitRedis = RateLimitRedis;
+type index_RateLimitResult = RateLimitResult;
+type index_ReferenceObject = ReferenceObject;
+type index_RetryConfig = RetryConfig;
+type index_UsageIssue = UsageIssue;
+declare const index___resetHttpClientBreakers: typeof __resetHttpClientBreakers;
+declare const index_buildCacheKey: typeof buildCacheKey;
+declare const index_buildConnection: typeof buildConnection;
+declare const index_buildLoaders: typeof buildLoaders;
+declare const index_buildOffsetPage: typeof buildOffsetPage;
+declare const index_clampGraphqlLimit: typeof clampGraphqlLimit;
+declare const index_clampLimit: typeof clampLimit;
+declare const index_clampOffset: typeof clampOffset;
+declare const index_createClaudeUsageAccumulator: typeof createClaudeUsageAccumulator;
+declare const index_createHttpClient: typeof createHttpClient;
+declare const index_createLeaderLease: typeof createLeaderLease;
+declare const index_decodeCursor: typeof decodeCursor;
+declare const index_dropOldPartitions: typeof dropOldPartitions;
+declare const index_encodeCursor: typeof encodeCursor;
+declare const index_ensureMonthlyPartitions: typeof ensureMonthlyPartitions;
+declare const index_getNamespaceVersion: typeof getNamespaceVersion;
+declare const index_httpClient: typeof httpClient;
+declare const index_invalidateNamespace: typeof invalidateNamespace;
+declare const index_monthlyPartitionName: typeof monthlyPartitionName;
+declare const index_normalizeClaudeUsage: typeof normalizeClaudeUsage;
+declare const index_normalizeCursorPagination: typeof normalizeCursorPagination;
+declare const index_normalizeOffsetPagination: typeof normalizeOffsetPagination;
+declare const index_normalizeOpenAIUsage: typeof normalizeOpenAIUsage;
+declare const index_normalizeRedisUrl: typeof normalizeRedisUrl;
+declare const index_paginate: typeof paginate;
+declare const index_rateLimitIncr: typeof rateLimitIncr;
+declare const index_resolveReferenceLoader: typeof resolveReferenceLoader;
+declare const index_toPrismaPage: typeof toPrismaPage;
+declare const index_validateInvocationAttemptInput: typeof validateInvocationAttemptInput;
+declare const index_validateInvocationAttemptReceipt: typeof validateInvocationAttemptReceipt;
+declare const index_validateInvocationDelivery: typeof validateInvocationDelivery;
+declare const index_validateInvocationIdentity: typeof validateInvocationIdentity;
+declare const index_validateInvocationUsageInput: typeof validateInvocationUsageInput;
+declare const index_validateInvocationUsageReceipt: typeof validateInvocationUsageReceipt;
+declare const index_validateInvocationUsageSummary: typeof validateInvocationUsageSummary;
+declare const index_withLeaderLock: typeof withLeaderLock;
+declare namespace index {
+  export { type index_BreakerConfig as BreakerConfig, type index_BuildConnectionOptions as BuildConnectionOptions, type index_CacheVersionRedis as CacheVersionRedis, index_CircuitBreakerOpenError as CircuitBreakerOpenError, type index_ClampLimitOptions as ClampLimitOptions, type index_ConnectionEdge as ConnectionEdge, type index_ConnectionResult as ConnectionResult, type index_CreateLeaderLeaseOptions as CreateLeaderLeaseOptions, type index_CursorPaginationInput as CursorPaginationInput, type index_CursorPayload as CursorPayload, type index_CursorPayloadValue as CursorPayloadValue, index_DEFAULT_GRAPHQL_PAGE_LIMIT as DEFAULT_GRAPHQL_PAGE_LIMIT, type index_DataLoaderLike as DataLoaderLike, type index_DropOldOptions as DropOldOptions, type index_EnsureMonthlyOptions as EnsureMonthlyOptions, type index_HttpClientConfig as HttpClientConfig, type index_HttpClientInit as HttpClientInit, index_InvocationAccountingCoordinator as InvocationAccountingCoordinator, type index_InvocationAccountingOptions as InvocationAccountingOptions, index_InvocationAccountingValidationError as InvocationAccountingValidationError, type index_InvocationAttemptInput as InvocationAttemptInput, type index_InvocationAttemptReceipt as InvocationAttemptReceipt, type index_InvocationCallerAdmission as InvocationCallerAdmission, type index_InvocationDelivery as InvocationDelivery, type index_InvocationDeliveryResult as InvocationDeliveryResult, type index_InvocationDeliveryStore as InvocationDeliveryStore, type index_InvocationIdentity as InvocationIdentity, type index_InvocationIntent as InvocationIntent, type index_InvocationReceipt as InvocationReceipt, type index_InvocationSummaryComponent as InvocationSummaryComponent, type index_InvocationSummarySelection as InvocationSummarySelection, type index_InvocationUsageInput as InvocationUsageInput, type index_InvocationUsageReceipt as InvocationUsageReceipt, type index_InvocationUsageSummary as InvocationUsageSummary, type index_LLMProviderAdapter as LLMProviderAdapter, type index_LLMRequest as LLMRequest, type index_LLMResponse as LLMResponse, index_LLMRouter as LLMRouter, type index_LLMRouterOptions as LLMRouterOptions, type index_LeaderLease as LeaderLease, type index_LeaderLockOptions as LeaderLockOptions, type index_LeaderLockRedis as LeaderLockRedis, type index_LeaderLockResult as LeaderLockResult, type index_LoaderBuilder as LoaderBuilder, type index_LoaderMap as LoaderMap, index_MAX_GRAPHQL_PAGE_LIMIT as MAX_GRAPHQL_PAGE_LIMIT, type index_NormalizedClaudeUsage as NormalizedClaudeUsage, type index_NormalizedCursorPagination as NormalizedCursorPagination, type index_NormalizedInvocationUsage as NormalizedInvocationUsage, type index_NormalizedOffsetPagination as NormalizedOffsetPagination, type index_OffsetPageResult as OffsetPageResult, type index_OffsetPaginationInput as OffsetPaginationInput, index_PROMPTS_V2_DOCUMENTS as PROMPTS_V2_DOCUMENTS, type index_PageInfo as PageInfo, type index_PaginateInput as PaginateInput, type index_PaginateResult as PaginateResult, type index_PrismaModelLike as PrismaModelLike, type index_PrismaRawClient as PrismaRawClient, type index_RateLimitInput as RateLimitInput, type index_RateLimitRedis as RateLimitRedis, type index_RateLimitResult as RateLimitResult, type index_ReferenceObject as ReferenceObject, type index_RetryConfig as RetryConfig, type index_UsageIssue as UsageIssue, index___resetHttpClientBreakers as __resetHttpClientBreakers, index_buildCacheKey as buildCacheKey, index_buildConnection as buildConnection, index_buildLoaders as buildLoaders, index_buildOffsetPage as buildOffsetPage, index_clampGraphqlLimit as clampGraphqlLimit, index_clampLimit as clampLimit, index_clampOffset as clampOffset, index_createClaudeUsageAccumulator as createClaudeUsageAccumulator, index_createHttpClient as createHttpClient, index_createLeaderLease as createLeaderLease, index_decodeCursor as decodeCursor, index_dropOldPartitions as dropOldPartitions, index_encodeCursor as encodeCursor, index_ensureMonthlyPartitions as ensureMonthlyPartitions, index_getNamespaceVersion as getNamespaceVersion, index_httpClient as httpClient, index_invalidateNamespace as invalidateNamespace, index_monthlyPartitionName as monthlyPartitionName, index_normalizeClaudeUsage as normalizeClaudeUsage, index_normalizeCursorPagination as normalizeCursorPagination, index_normalizeOffsetPagination as normalizeOffsetPagination, index_normalizeOpenAIUsage as normalizeOpenAIUsage, index_normalizeRedisUrl as normalizeRedisUrl, index_paginate as paginate, index_rateLimitIncr as rateLimitIncr, index_resolveReferenceLoader as resolveReferenceLoader, index_toPrismaPage as toPrismaPage, index_validateInvocationAttemptInput as validateInvocationAttemptInput, index_validateInvocationAttemptReceipt as validateInvocationAttemptReceipt, index_validateInvocationDelivery as validateInvocationDelivery, index_validateInvocationIdentity as validateInvocationIdentity, index_validateInvocationUsageInput as validateInvocationUsageInput, index_validateInvocationUsageReceipt as validateInvocationUsageReceipt, index_validateInvocationUsageSummary as validateInvocationUsageSummary, index_withLeaderLock as withLeaderLock };
+}
+
+export { PROMPTS_V2_DOCUMENTS as $, type InvocationUsageInput as A, type BreakerConfig as B, type CacheVersionRedis as C, DEFAULT_GRAPHQL_PAGE_LIMIT as D, type EnsureMonthlyOptions as E, type InvocationUsageReceipt as F, type InvocationUsageSummary as G, type HttpClientConfig as H, InvocationAccountingCoordinator as I, type LLMRequest as J, type LLMResponse as K, type LLMProviderAdapter as L, LLMRouter as M, type LLMRouterOptions as N, type LeaderLease as O, type LeaderLockOptions as P, type LeaderLockRedis as Q, type LeaderLockResult as R, type LoaderBuilder as S, type LoaderMap as T, MAX_GRAPHQL_PAGE_LIMIT as U, type NormalizedClaudeUsage as V, type NormalizedCursorPagination as W, type NormalizedInvocationUsage as X, type NormalizedOffsetPagination as Y, type OffsetPageResult as Z, type OffsetPaginationInput as _, type BuildConnectionOptions as a, type PageInfo as a0, type PaginateInput as a1, type PaginateResult as a2, type PrismaModelLike as a3, type PrismaRawClient as a4, type RateLimitInput as a5, type RateLimitRedis as a6, type RateLimitResult as a7, type ReferenceObject as a8, type RetryConfig as a9, rateLimitIncr as aA, resolveReferenceLoader as aB, toPrismaPage as aC, validateInvocationAttemptInput as aD, validateInvocationAttemptReceipt as aE, validateInvocationDelivery as aF, validateInvocationIdentity as aG, validateInvocationUsageInput as aH, validateInvocationUsageReceipt as aI, validateInvocationUsageSummary as aJ, withLeaderLock as aK, type UsageIssue as aa, __resetHttpClientBreakers as ab, buildCacheKey as ac, buildConnection as ad, buildLoaders as ae, buildOffsetPage as af, clampGraphqlLimit as ag, clampLimit as ah, clampOffset as ai, createClaudeUsageAccumulator as aj, createHttpClient as ak, createLeaderLease as al, decodeCursor as am, dropOldPartitions as an, encodeCursor as ao, ensureMonthlyPartitions as ap, getNamespaceVersion as aq, httpClient as ar, invalidateNamespace as as, monthlyPartitionName as at, normalizeClaudeUsage as au, normalizeCursorPagination as av, normalizeOffsetPagination as aw, normalizeOpenAIUsage as ax, normalizeRedisUrl as ay, paginate as az, CircuitBreakerOpenError as b, type ClampLimitOptions as c, type ConnectionEdge as d, type ConnectionResult as e, type CreateLeaderLeaseOptions as f, type CursorPaginationInput as g, type CursorPayload as h, index as i, type CursorPayloadValue as j, type DataLoaderLike as k, type DropOldOptions as l, type HttpClientInit as m, type InvocationAccountingOptions as n, InvocationAccountingValidationError as o, type InvocationAttemptInput as p, type InvocationAttemptReceipt as q, type InvocationCallerAdmission as r, type InvocationDelivery as s, type InvocationDeliveryResult as t, type InvocationDeliveryStore as u, type InvocationIdentity as v, type InvocationIntent as w, type InvocationReceipt as x, type InvocationSummaryComponent as y, type InvocationSummarySelection as z };

package/dist/index.d.ts

@@ -36,7 +36,7 @@ export { i as Crypto } from './index-e_18DzAg.js';
 export { i as Gateway } from './index-Dy6neH2G.js';
 export { i as FeatureFlags } from './index-Rc5EphmY.js';
 export { i as Captcha, R as RecaptchaVerifyOptions, a as RecaptchaVerifyResult, b as isCaptchaEnabled, v as verifyCaptcha, c as verifyCaptchaIfEnabled } from './index-B70b5mYS.js';
-export { i as Platform } from './index-PJZzGd8r.js';
+export { i as Platform } from './index-DfYu1p9e.js';
 export { N as NAME_MAX_LENGTH, a as NAME_MIN_LENGTH, b as NameErrorCode, c as NameValidationResult, U as USERNAME_MAX_LENGTH, d as USERNAME_MIN_LENGTH, e as UserFieldError, f as UserFieldKey, g as UserFieldsValidationResult, h as UsernameErrorCode, i as UsernameValidationResult, V as ValidatedUserFields, j as Validation, l as lengthInCodePoints, v as validateName, k as validateUserFields, m as validateUsername } from './index-B2jIInhp.js';
 export { E as EmitGeneration, P as PRODUCT_RENAMES, a as PRODUCT_RENAME_EMIT, b as PRODUCT_SLUG_ALIASES, i as ProductAlias, c as ProductRename, R as RENAME_CONCERNS, d as RenameConcern, e as billingIdVariants, f as emitBillingId, g as emitName, h as emitProductSlug, j as emitQuotaKey, k as emitRbacResource, l as emitTemplateKey, m as isLegacyName, n as isSameBillingId, o as isSameGraphQLName, p as isSameName, q as isSameProductSlug, r as isSameQuotaKey, s as isSameRbacResource, t as isSameTemplateKey, u as nameVariants, v as normalizeBillingId, w as normalizeGraphQLName, x as normalizeProductSlug, y as normalizeQuotaKey, z as normalizeRbacResource, A as normalizeTemplateKey, B as productSlugVariants, C as quotaKeyVariants, D as rbacResourceVariants, F as readRenamedEnv, G as templateKeyVariants, H as toCurrentName, I as toLegacyName } from './index-BuAj5nXg.js';
 export { C as CircuitBreakerConfig, h as DEFAULT_CIRCUIT_BREAKER_CONFIG, i as DEFAULT_GATEWAY_RETRY_CONFIG, D as DEFAULT_GATEWAY_ROUTING, b as DEFAULT_LAYER_RESOURCES, c as DEFAULT_LAYER_STREAMS, f as GatewayRequestHeaders, g as GatewayRetryConfig, G as GatewayRoutingConfig, L as LayerConfig, a as LayerFullConfig, d as LayerGatewayConfig, e as LayerResourceUrls, S as ServiceLayer } from './layer-GNAVXBMf.js';

package/dist/index.js

@@ -4,7 +4,7 @@ import { ActivityModule, UsageModule, TrackerModule } from './chunk-NCC5UN3L.js'
 export { ActivityModule, TrackerModule, UsageModule } from './chunk-NCC5UN3L.js';
 export { NAME_MAX_LENGTH, NAME_MIN_LENGTH, USERNAME_MAX_LENGTH, USERNAME_MIN_LENGTH, validation_exports as Validation, lengthInCodePoints, validateName, validateUserFields, validateUsername } from './chunk-AHEXIONU.js';
 export { observability_exports as Observability } from './chunk-VAT66FJA.js';
-export { platform_exports as Platform } from './chunk-Z5BURBFZ.js';
+export { platform_exports as Platform } from './chunk-N2UT3ESH.js';
 export { prisma_exports as Prisma } from './chunk-E5HKS7KD.js';
 export { PRODUCT_RENAMES, PRODUCT_RENAME_EMIT, PRODUCT_SLUG_ALIASES, product_alias_exports as ProductAlias, RENAME_CONCERNS, billingIdVariants, emitBillingId, emitName, emitProductSlug, emitQuotaKey, emitRbacResource, emitTemplateKey, isLegacyName, isSameBillingId, isSameGraphQLName, isSameName, isSameProductSlug, isSameQuotaKey, isSameRbacResource, isSameTemplateKey, nameVariants, normalizeBillingId, normalizeGraphQLName, normalizeProductSlug, normalizeQuotaKey, normalizeRbacResource, normalizeTemplateKey, productSlugVariants, quotaKeyVariants, rbacResourceVariants, readRenamedEnv, templateKeyVariants, toCurrentName, toLegacyName } from './chunk-OBBCR6WY.js';
 import { RBACModule } from './chunk-5JNHVKHG.js';

package/dist/platform/index.d.ts

@@ -1 +1 @@
-export { B as BreakerConfig, a as BuildConnectionOptions, C as CacheVersionRedis, b as CircuitBreakerOpenError, c as ClampLimitOptions, d as ConnectionEdge, e as ConnectionResult, f as CreateLeaderLeaseOptions, g as CursorPaginationInput, h as CursorPayload, j as CursorPayloadValue, D as DEFAULT_GRAPHQL_PAGE_LIMIT, k as DataLoaderLike, l as DropOldOptions, E as EnsureMonthlyOptions, H as HttpClientConfig, m as HttpClientInit, L as LLMProviderAdapter, n as LLMRequest, o as LLMResponse, p as LLMRouter, q as LLMRouterOptions, r as LeaderLease, s as LeaderLockOptions, t as LeaderLockRedis, u as LeaderLockResult, v as LoaderBuilder, w as LoaderMap, M as MAX_GRAPHQL_PAGE_LIMIT, N as NormalizedCursorPagination, x as NormalizedOffsetPagination, O as OffsetPageResult, y as OffsetPaginationInput, P as PageInfo, z as PaginateInput, A as PaginateResult, F as PrismaModelLike, G as PrismaRawClient, R as RateLimitInput, I as RateLimitRedis, J as RateLimitResult, K as ReferenceObject, Q as RetryConfig, _ as __resetHttpClientBreakers, S as buildCacheKey, T as buildConnection, U as buildLoaders, V as buildOffsetPage, W as clampGraphqlLimit, X as clampLimit, Y as clampOffset, Z as createHttpClient, $ as createLeaderLease, a0 as decodeCursor, a1 as dropOldPartitions, a2 as encodeCursor, a3 as ensureMonthlyPartitions, a4 as getNamespaceVersion, a5 as httpClient, a6 as invalidateNamespace, a7 as monthlyPartitionName, a8 as normalizeCursorPagination, a9 as normalizeOffsetPagination, aa as normalizeRedisUrl, ab as paginate, ac as rateLimitIncr, ad as resolveReferenceLoader, ae as toPrismaPage, af as withLeaderLock } from '../index-PJZzGd8r.js';
+export { B as BreakerConfig, a as BuildConnectionOptions, C as CacheVersionRedis, b as CircuitBreakerOpenError, c as ClampLimitOptions, d as ConnectionEdge, e as ConnectionResult, f as CreateLeaderLeaseOptions, g as CursorPaginationInput, h as CursorPayload, j as CursorPayloadValue, D as DEFAULT_GRAPHQL_PAGE_LIMIT, k as DataLoaderLike, l as DropOldOptions, E as EnsureMonthlyOptions, H as HttpClientConfig, m as HttpClientInit, I as InvocationAccountingCoordinator, n as InvocationAccountingOptions, o as InvocationAccountingValidationError, p as InvocationAttemptInput, q as InvocationAttemptReceipt, r as InvocationCallerAdmission, s as InvocationDelivery, t as InvocationDeliveryResult, u as InvocationDeliveryStore, v as InvocationIdentity, w as InvocationIntent, x as InvocationReceipt, y as InvocationSummaryComponent, z as InvocationSummarySelection, A as InvocationUsageInput, F as InvocationUsageReceipt, G as InvocationUsageSummary, L as LLMProviderAdapter, J as LLMRequest, K as LLMResponse, M as LLMRouter, N as LLMRouterOptions, O as LeaderLease, P as LeaderLockOptions, Q as LeaderLockRedis, R as LeaderLockResult, S as LoaderBuilder, T as LoaderMap, U as MAX_GRAPHQL_PAGE_LIMIT, V as NormalizedClaudeUsage, W as NormalizedCursorPagination, X as NormalizedInvocationUsage, Y as NormalizedOffsetPagination, Z as OffsetPageResult, _ as OffsetPaginationInput, $ as PROMPTS_V2_DOCUMENTS, a0 as PageInfo, a1 as PaginateInput, a2 as PaginateResult, a3 as PrismaModelLike, a4 as PrismaRawClient, a5 as RateLimitInput, a6 as RateLimitRedis, a7 as RateLimitResult, a8 as ReferenceObject, a9 as RetryConfig, aa as UsageIssue, ab as __resetHttpClientBreakers, ac as buildCacheKey, ad as buildConnection, ae as buildLoaders, af as buildOffsetPage, ag as clampGraphqlLimit, ah as clampLimit, ai as clampOffset, aj as createClaudeUsageAccumulator, ak as createHttpClient, al as createLeaderLease, am as decodeCursor, an as dropOldPartitions, ao as encodeCursor, ap as ensureMonthlyPartitions, aq as getNamespaceVersion, ar as httpClient, as as invalidateNamespace, at as monthlyPartitionName, au as normalizeClaudeUsage, av as normalizeCursorPagination, aw as normalizeOffsetPagination, ax as normalizeOpenAIUsage, ay as normalizeRedisUrl, az as paginate, aA as rateLimitIncr, aB as resolveReferenceLoader, aC as toPrismaPage, aD as validateInvocationAttemptInput, aE as validateInvocationAttemptReceipt, aF as validateInvocationDelivery, aG as validateInvocationIdentity, aH as validateInvocationUsageInput, aI as validateInvocationUsageReceipt, aJ as validateInvocationUsageSummary, aK as withLeaderLock } from '../index-DfYu1p9e.js';

package/dist/platform/index.js

@@ -1,4 +1,5 @@
-export { CircuitBreakerOpenError, DEFAULT_GRAPHQL_PAGE_LIMIT, LLMRouter, MAX_GRAPHQL_PAGE_LIMIT, __resetHttpClientBreakers, buildCacheKey, buildConnection, buildLoaders, buildOffsetPage, clampGraphqlLimit, clampLimit, clampOffset, createHttpClient, createLeaderLease, decodeCursor, dropOldPartitions, encodeCursor, ensureMonthlyPartitions, getNamespaceVersion, httpClient, invalidateNamespace, monthlyPartitionName, normalizeCursorPagination, normalizeOffsetPagination, normalizeRedisUrl, paginate, rateLimitIncr, resolveReferenceLoader, toPrismaPage, withLeaderLock } from '../chunk-Z5BURBFZ.js';
+export { CircuitBreakerOpenError, DEFAULT_GRAPHQL_PAGE_LIMIT, InvocationAccountingCoordinator, InvocationAccountingValidationError, LLMRouter, MAX_GRAPHQL_PAGE_LIMIT, PROMPTS_V2_DOCUMENTS, __resetHttpClientBreakers, buildCacheKey, buildConnection, buildLoaders, buildOffsetPage, clampGraphqlLimit, clampLimit, clampOffset, createClaudeUsageAccumulator, createHttpClient, createLeaderLease, decodeCursor, dropOldPartitions, encodeCursor, ensureMonthlyPartitions, getNamespaceVersion, httpClient, invalidateNamespace, monthlyPartitionName, normalizeClaudeUsage, normalizeCursorPagination, normalizeOffsetPagination, normalizeOpenAIUsage, normalizeRedisUrl, paginate, rateLimitIncr, resolveReferenceLoader, toPrismaPage, validateInvocationAttemptInput, validateInvocationAttemptReceipt, validateInvocationDelivery, validateInvocationIdentity, validateInvocationUsageInput, validateInvocationUsageReceipt, validateInvocationUsageSummary, withLeaderLock } from '../chunk-N2UT3ESH.js';
+import '../chunk-OBBCR6WY.js';
 import '../chunk-RU266375.js';
 import '../chunk-XE4OXN2W.js';
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@burdenoff/be-sdk",
-  "version": "2026.1015.2",
+  "version": "2026.1017.1",
   "description": "Backend SDK for Burdenoff products providing unified access to notifications, RBAC, activity tracking, usage monitoring, and more",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",