@scrawn/core 0.0.2 → 0.0.3

package/dist/core/grpc/index.js

@@ -1,11 +0,0 @@
-/**
- * gRPC abstraction layer - Type-safe fluent API for gRPC calls.
- *
- * This module provides a beautiful, type-safe interface for making gRPC calls
- * with automatic type inference, compile-time validation, and a fluent API.
- *
- * @module grpc
- */
-export { GrpcClient } from './client.js';
-export { RequestBuilder } from './requestBuilder.js';
-//# sourceMappingURL=index.js.map

package/dist/core/grpc/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/grpc/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/core/grpc/requestBuilder.d.ts

@@ -1,116 +0,0 @@
-/**
- * Type-safe fluent API for building and executing gRPC requests.
- *
- * This module provides a beautiful chain-able interface that ensures:
- * - Compile-time type safety for all operations
- * - Autocomplete for service methods and payload fields
- * - Runtime validation of request state
- * - Clean separation of concerns
- *
- * @example
- * ```typescript
- * const response = await client
- *   .newCall(EventService, 'registerEvent')
- *   .addHeader('x-request-id', '123')
- *   .addPayload({
- *     type: EventType.SDK_CALL,
- *     userId: 'user_123',
- *     data: { case: 'sdkCall', value: { sdkCallType: SDKCallType.RAW, debitAmount: 10 } }
- *   })
- *   .request();
- * ```
- */
-import type { Transport } from '@connectrpc/connect';
-import type { ServiceType } from '@bufbuild/protobuf';
-import type { ServiceMethodNames, MethodInput, MethodOutput } from './types.js';
-/**
- * Builder for constructing type-safe gRPC requests.
- *
- * This class implements a fluent interface where each method returns `this`,
- * allowing for method chaining. Type parameters ensure that the payload type
- * matches the selected service method at compile time.
- *
- * @template S - The gRPC service type
- * @template M - The method name on the service (string literal)
- */
-export declare class RequestBuilder<S extends ServiceType, M extends ServiceMethodNames<S>> {
-    private readonly client;
-    private readonly methodName;
-    private readonly headers;
-    private payload;
-    private readonly state;
-    /**
-     * @internal
-     * Constructs a new RequestBuilder. Use GrpcClient.newCall() instead.
-     */
-    constructor(transport: Transport, service: S, methodName: M);
-    /**
-     * Add a header to the request.
-     *
-     * Headers are sent with the gRPC call and can be used for authentication,
-     * tracing, or custom metadata. This method can be called multiple times
-     * to add multiple headers.
-     *
-     * @param key - Header name (e.g., 'authorization', 'x-request-id')
-     * @param value - Header value
-     * @returns The builder instance for chaining
-     *
-     * @example
-     * ```typescript
-     * builder
-     *   .addHeader('authorization', 'Bearer token123')
-     *   .addHeader('x-request-id', 'abc-def-123')
-     * ```
-     */
-    addHeader(key: string, value: string): this;
-    /**
-     * Set the request payload.
-     *
-     * The payload type is automatically inferred from the service method,
-     * providing full autocomplete and type checking. This method can only
-     * be called once per request to prevent accidental overwrites.
-     *
-     * @param payload - The request payload (type-checked against the method's input type)
-     * @returns The builder instance for chaining
-     * @throws Error if payload has already been set
-     *
-     * @example
-     * ```typescript
-     * builder.addPayload({
-     *   type: EventType.SDK_CALL,
-     *   userId: 'user_123',
-     *   data: {
-     *     case: 'sdkCall',
-     *     value: {
-     *       sdkCallType: SDKCallType.RAW,
-     *       debitAmount: 10
-     *     }
-     *   }
-     * })
-     * ```
-     */
-    addPayload(payload: MethodInput<S, M> extends infer T ? Partial<T> : never): this;
-    /**
-     * Execute the gRPC request.
-     *
-     * Validates that a payload has been set, then makes the actual gRPC call
-     * using the configured service, method, headers, and payload. The response
-     * type is automatically inferred from the service method.
-     *
-     * @returns A promise that resolves to the typed response
-     * @throws Error if no payload has been set
-     * @throws Error if the gRPC call fails
-     *
-     * @example
-     * ```typescript
-     * const response = await builder
-     *   .addPayload({ userId: 'user_123', ... })
-     *   .request();
-     *
-     * // response is fully typed based on the method's output type
-     * console.log(response.random);
-     * ```
-     */
-    request(): Promise<MethodOutput<S, M>>;
-}
-//# sourceMappingURL=requestBuilder.d.ts.map

package/dist/core/grpc/requestBuilder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"requestBuilder.d.ts","sourceRoot":"","sources":["../../../src/core/grpc/requestBuilder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAU,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAGtD,OAAO,KAAK,EACV,kBAAkB,EAClB,WAAW,EACX,YAAY,EAGb,MAAM,YAAY,CAAC;AAIpB;;;;;;;;;GASG;AACH,qBAAa,cAAc,CACzB,CAAC,SAAS,WAAW,EACrB,CAAC,SAAS,kBAAkB,CAAC,CAAC,CAAC;IAE/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAY;IACnC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAI;IAC/B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IACvC,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAuC;IAE7D;;;OAGG;gBAED,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,CAAC,EACV,UAAU,EAAE,CAAC;IAOf;;;;;;;;;;;;;;;;;OAiBG;IACH,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAK3C;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,UAAU,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,IAAI;IAajF;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,OAAO,IAAI,OAAO,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CA6B7C"}

package/dist/core/grpc/requestBuilder.js

@@ -1,146 +0,0 @@
-/**
- * Type-safe fluent API for building and executing gRPC requests.
- *
- * This module provides a beautiful chain-able interface that ensures:
- * - Compile-time type safety for all operations
- * - Autocomplete for service methods and payload fields
- * - Runtime validation of request state
- * - Clean separation of concerns
- *
- * @example
- * ```typescript
- * const response = await client
- *   .newCall(EventService, 'registerEvent')
- *   .addHeader('x-request-id', '123')
- *   .addPayload({
- *     type: EventType.SDK_CALL,
- *     userId: 'user_123',
- *     data: { case: 'sdkCall', value: { sdkCallType: SDKCallType.RAW, debitAmount: 10 } }
- *   })
- *   .request();
- * ```
- */
-import { createClient } from '@connectrpc/connect';
-import { ScrawnLogger } from '../../utils/logger.js';
-const log = new ScrawnLogger('RequestBuilder');
-/**
- * Builder for constructing type-safe gRPC requests.
- *
- * This class implements a fluent interface where each method returns `this`,
- * allowing for method chaining. Type parameters ensure that the payload type
- * matches the selected service method at compile time.
- *
- * @template S - The gRPC service type
- * @template M - The method name on the service (string literal)
- */
-export class RequestBuilder {
-    /**
-     * @internal
-     * Constructs a new RequestBuilder. Use GrpcClient.newCall() instead.
-     */
-    constructor(transport, service, methodName) {
-        this.headers = {};
-        this.payload = null;
-        this.state = { hasPayload: false };
-        // Create a typed client for this service
-        this.client = createClient(service, transport);
-        this.methodName = methodName;
-    }
-    /**
-     * Add a header to the request.
-     *
-     * Headers are sent with the gRPC call and can be used for authentication,
-     * tracing, or custom metadata. This method can be called multiple times
-     * to add multiple headers.
-     *
-     * @param key - Header name (e.g., 'authorization', 'x-request-id')
-     * @param value - Header value
-     * @returns The builder instance for chaining
-     *
-     * @example
-     * ```typescript
-     * builder
-     *   .addHeader('authorization', 'Bearer token123')
-     *   .addHeader('x-request-id', 'abc-def-123')
-     * ```
-     */
-    addHeader(key, value) {
-        this.headers[key] = value;
-        return this;
-    }
-    /**
-     * Set the request payload.
-     *
-     * The payload type is automatically inferred from the service method,
-     * providing full autocomplete and type checking. This method can only
-     * be called once per request to prevent accidental overwrites.
-     *
-     * @param payload - The request payload (type-checked against the method's input type)
-     * @returns The builder instance for chaining
-     * @throws Error if payload has already been set
-     *
-     * @example
-     * ```typescript
-     * builder.addPayload({
-     *   type: EventType.SDK_CALL,
-     *   userId: 'user_123',
-     *   data: {
-     *     case: 'sdkCall',
-     *     value: {
-     *       sdkCallType: SDKCallType.RAW,
-     *       debitAmount: 10
-     *     }
-     *   }
-     * })
-     * ```
-     */
-    addPayload(payload) {
-        if (this.state.hasPayload) {
-            throw new Error('Payload has already been set. Cannot add payload multiple times. ' +
-                'Create a new request builder if you need to make another call.');
-        }
-        this.payload = payload;
-        this.state.hasPayload = true;
-        return this;
-    }
-    /**
-     * Execute the gRPC request.
-     *
-     * Validates that a payload has been set, then makes the actual gRPC call
-     * using the configured service, method, headers, and payload. The response
-     * type is automatically inferred from the service method.
-     *
-     * @returns A promise that resolves to the typed response
-     * @throws Error if no payload has been set
-     * @throws Error if the gRPC call fails
-     *
-     * @example
-     * ```typescript
-     * const response = await builder
-     *   .addPayload({ userId: 'user_123', ... })
-     *   .request();
-     *
-     * // response is fully typed based on the method's output type
-     * console.log(response.random);
-     * ```
-     */
-    async request() {
-        if (!this.state.hasPayload || this.payload === null) {
-            throw new Error('Cannot make request without payload. Call addPayload() first.');
-        }
-        try {
-            log.info(`Making gRPC call to ${this.methodName}`);
-            log.debug(`Headers: ${JSON.stringify(this.headers)}`);
-            log.debug(`Payload: ${JSON.stringify(this.payload)}`);
-            // The actual gRPC call - fully type-safe!
-            const response = await this.client[this.methodName](this.payload, { headers: this.headers });
-            log.info(`Successfully completed gRPC call to ${this.methodName}`);
-            return response;
-        }
-        catch (error) {
-            log.error(`gRPC call to ${this.methodName} failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            throw error;
-        }
-    }
-}
-//# sourceMappingURL=requestBuilder.js.map

package/dist/core/grpc/requestBuilder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"requestBuilder.js","sourceRoot":"","sources":["../../../src/core/grpc/requestBuilder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AASrD,MAAM,GAAG,GAAG,IAAI,YAAY,CAAC,gBAAgB,CAAC,CAAC;AAE/C;;;;;;;;;GASG;AACH,MAAM,OAAO,cAAc;IAUzB;;;OAGG;IACH,YACE,SAAoB,EACpB,OAAU,EACV,UAAa;QAXE,YAAO,GAAY,EAAE,CAAC;QAC/B,YAAO,GAAQ,IAAI,CAAC;QACX,UAAK,GAAiB,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC;QAW3D,yCAAyC;QACzC,IAAI,CAAC,MAAM,GAAG,YAAY,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;QAC/C,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;IAC/B,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,SAAS,CAAC,GAAW,EAAE,KAAa;QAClC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;QAC1B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,UAAU,CAAC,OAA+D;QACxE,IAAI,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CACb,mEAAmE;gBACnE,gEAAgE,CACjE,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC;QAC7B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,KAAK,CAAC,OAAO;QACX,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,IAAI,IAAI,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;YACpD,MAAM,IAAI,KAAK,CACb,+DAA+D,CAChE,CAAC;QACJ,CAAC;QAED,IAAI,CAAC;YACH,GAAG,CAAC,IAAI,CAAC,uBAAuB,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;YACnD,GAAG,CAAC,KAAK,CAAC,YAAY,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;YACtD,GAAG,CAAC,KAAK,CAAC,YAAY,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;YAEtD,0CAA0C;YAC1C,MAAM,QAAQ,GAAG,MAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAS,CAC1D,IAAI,CAAC,OAAO,EACZ,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAC1B,CAAC;YAEF,GAAG,CAAC,IAAI,CAAC,uCAAuC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;YACnE,OAAO,QAA8B,CAAC;QACxC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,GAAG,CAAC,KAAK,CACP,gBAAgB,IAAI,CAAC,UAAU,YAC7B,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,eAC3C,EAAE,CACH,CAAC;YACF,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;CACF"}

package/dist/core/grpc/types.d.ts

@@ -1,54 +0,0 @@
-/**
- * Core type system for the gRPC client abstraction layer.
- *
- * This module provides compile-time type safety for all gRPC operations,
- * ensuring that payloads, headers, and responses are correctly typed based
- * on the service and method being called.
- */
-import type { ServiceType } from '@bufbuild/protobuf';
-import type { MessageType } from '@bufbuild/protobuf';
-/**
- * Extract all method names from a service as a union of string literals.
- * This provides autocomplete and compile-time validation of method names.
- */
-export type ServiceMethodNames<S extends ServiceType> = keyof S['methods'] & string;
-/**
- * Get the input MessageType (constructor) for a specific method on a service.
- */
-export type MethodInputType<S extends ServiceType, M extends ServiceMethodNames<S>> = S['methods'][M] extends {
-    I: infer I;
-} ? I : never;
-/**
- * Get the output MessageType (constructor) for a specific method on a service.
- */
-export type MethodOutputType<S extends ServiceType, M extends ServiceMethodNames<S>> = S['methods'][M] extends {
-    O: infer O;
-} ? O : never;
-/**
- * Convert a MessageType to its Message instance type.
- * This extracts the actual Message type from a MessageType constructor.
- */
-export type MessageTypeToMessage<T> = T extends MessageType<infer M> ? M : never;
-/**
- * Get the input Message type for a specific method on a service.
- * This is what you'll use for the payload type.
- */
-export type MethodInput<S extends ServiceType, M extends ServiceMethodNames<S>> = MessageTypeToMessage<MethodInputType<S, M>>;
-/**
- * Get the output Message type for a specific method on a service.
- * This is what you'll get back from the request.
- */
-export type MethodOutput<S extends ServiceType, M extends ServiceMethodNames<S>> = MessageTypeToMessage<MethodOutputType<S, M>>;
-/**
- * HTTP headers as key-value pairs.
- */
-export interface Headers {
-    [key: string]: string;
-}
-/**
- * State tracking for the request builder to prevent duplicate operations.
- */
-export interface RequestState {
-    hasPayload: boolean;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/core/grpc/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/core/grpc/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEtD;;;GAGG;AACH,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,WAAW,IAAI,MAAM,CAAC,CAAC,SAAS,CAAC,GAAG,MAAM,CAAC;AAEpF;;GAEG;AACH,MAAM,MAAM,eAAe,CACzB,CAAC,SAAS,WAAW,EACrB,CAAC,SAAS,kBAAkB,CAAC,CAAC,CAAC,IAC7B,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS;IAAE,CAAC,EAAE,MAAM,CAAC,CAAA;CAAE,GAAG,CAAC,GAAG,KAAK,CAAC;AAEvD;;GAEG;AACH,MAAM,MAAM,gBAAgB,CAC1B,CAAC,SAAS,WAAW,EACrB,CAAC,SAAS,kBAAkB,CAAC,CAAC,CAAC,IAC7B,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS;IAAE,CAAC,EAAE,MAAM,CAAC,CAAA;CAAE,GAAG,CAAC,GAAG,KAAK,CAAC;AAEvD;;;GAGG;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAAI,CAAC,SAAS,WAAW,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAEjF;;;GAGG;AACH,MAAM,MAAM,WAAW,CACrB,CAAC,SAAS,WAAW,EACrB,CAAC,SAAS,kBAAkB,CAAC,CAAC,CAAC,IAC7B,oBAAoB,CAAC,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAEhD;;;GAGG;AACH,MAAM,MAAM,YAAY,CACtB,CAAC,SAAS,WAAW,EACrB,CAAC,SAAS,kBAAkB,CAAC,CAAC,CAAC,IAC7B,oBAAoB,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAEjD;;GAEG;AACH,MAAM,WAAW,OAAO;IACtB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE,OAAO,CAAC;CACrB"}

package/dist/core/grpc/types.js

@@ -1,9 +0,0 @@
-/**
- * Core type system for the gRPC client abstraction layer.
- *
- * This module provides compile-time type safety for all gRPC operations,
- * ensuring that payloads, headers, and responses are correctly typed based
- * on the service and method being called.
- */
-export {};
-//# sourceMappingURL=types.js.map

package/dist/core/grpc/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/core/grpc/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/dist/core/scrawn.d.ts

@@ -1,197 +0,0 @@
-import type { EventPayload, MiddlewareRequest, MiddlewareResponse, MiddlewareNext, MiddlewareEventConfig } from './types/event.js';
-import type { AllCredentials } from './types/auth.js';
-/**
- * Main SDK class for Scrawn billing infrastructure.
- *
- * Manages authentication, event tracking, and credential caching.
- * All event consumption methods are available directly on the SDK instance.
- *
- * @example
- * ```typescript
- * import { Scrawn } from '@scrawn/core';
- *
- * // Initialize SDK
- * const scrawn = new Scrawn({ apiKey: process.env.SCRAWN_KEY });
- * await scrawn.init();
- *
- * // Track SDK calls
- * await scrawn.sdkCallEventConsumer({ userId: 'u123', debitAmount: 3 });
- * ```
- */
-export declare class Scrawn {
-    /** Map of authentication method names to their implementations */
-    private authMethods;
-    /**
-     * Cache of credentials keyed by auth method name for performance.
-     * Keys are restricted to registered auth method names only.
-     */
-    private credCache;
-    /** API key used for default authentication */
-    private apiKey;
-    /** gRPC client for making type-safe API calls */
-    private grpcClient;
-    /**
-     * Creates a new Scrawn SDK instance.
-     *
-     * @param config - Configuration object
-     * @param config.apiKey - Your Scrawn API key for authentication
-     * @param config.baseURL - Base URL for the Scrawn API (e.g., 'https://api.scrawn.dev')
-     *
-     * @example
-     * ```typescript
-     * const scrawn = new Scrawn({
-     *   apiKey: 'sk_test_...',
-     *   baseURL: 'https://api.scrawn.dev'
-     * });
-     * await scrawn.init();
-     * ```
-     */
-    constructor(config: {
-        apiKey: AllCredentials['apiKey'];
-        baseURL: string;
-    });
-    /**
-     * Register an authentication method with the SDK.
-     *
-     * Auth methods handle credential management and can be shared across multiple event types.
-     * Only auth method names defined in AuthRegistry are allowed.
-     *
-     * @param name - Unique identifier for this auth method (must be in AuthRegistry)
-     * @param auth - Instance of an AuthBase implementation
-     *
-     * @example
-     * ```typescript
-     * scrawn.registerAuthMethod('api', new ApiKeyAuth('sk_test_...'));
-     * ```
-     */
-    private registerAuthMethod;
-    /**
-     * Get credentials for a specific authentication method.
-     *
-     * Credentials are cached after the first fetch for performance.
-     * Subsequent calls return the cached value without re-fetching.
-     * Only auth method names defined in AuthRegistry are allowed.
-     *
-     * @param authMethodName - Name of the auth method to get credentials for (must be in AuthRegistry)
-     * @returns A promise that resolves to the credentials object
-     * @throws Error if the auth method is not registered
-     *
-     * @example
-     * ```typescript
-     * const creds = await scrawn.getCredsFor('api');
-     * // { apiKey: 'sk_test_...' }
-     * ```
-     */
-    private getCredsFor;
-    /**
-     * Track an SDK call event.
-     *
-     * Records SDK usage to the Scrawn backend for billing tracking.
-     * The event is authenticated using the API key provided during SDK initialization.
-     *
-     * @param payload - The SDK call data to track
-     * @param payload.userId - Unique identifier of the user making the call
-     * @param payload.debitAmount - Amount to debit from the user's account
-     * @returns A promise that resolves when the event is tracked
-     * @throws Error if payload validation fails
-     *
-     * @example
-     * ```typescript
-     * await scrawn.sdkCallEventConsumer({
-     *   userId: 'user_abc123',
-     *   debitAmount: 10
-     * });
-     * ```
-     */
-    sdkCallEventConsumer(payload: EventPayload): Promise<void>;
-    /**
-     * Create an Express-compatible middleware for tracking API endpoint usage.
-     *
-     * This middleware automatically tracks requests to your API endpoints for billing purposes.
-     * You provide an extractor function that determines the userId and debitAmount from each request.
-     * Optionally, you can provide a whitelist array to only track specific endpoints,
-     * or a blacklist array to exclude specific endpoints from tracking.
-     *
-     * The middleware is framework-agnostic and works with Express, Fastify, and similar frameworks.
-     *
-     * @param config - Configuration object for the middleware
-     * @param config.extractor - Function that extracts userId and debitAmount from the request. Return null to skip tracking.
-     * @param config.whitelist - Optional array of endpoint patterns to track. Supports wildcards:
-     *                            - Exact match: /api/users
-     *                            - Single segment (*): /api/* matches /api/users but not /api/users/123
-     *                            - Multi-segment (**): /api/** matches any path starting with /api/
-     *                            - Mixed: /api/star/profile, **.php
-     *                            Takes precedence over blacklist. If omitted, all requests will be tracked.
-     * @param config.blacklist - Optional array of endpoint patterns to exclude. Same wildcard support as whitelist.
-     *                            Only applies to endpoints not in the whitelist.
-     *
-     * @returns Express-compatible middleware function
-     *
-     * @example
-     * ```typescript
-     * // Track all endpoints
-     * app.use(scrawn.middlewareEventConsumer({
-     *   extractor: (req) => ({
-     *     userId: req.user.id,
-     *     debitAmount: 1
-     *   })
-     * }));
-     *
-     * // Track only specific endpoints with wildcards
-     * app.use(scrawn.middlewareEventConsumer({
-     *   extractor: (req) => ({
-     *     userId: req.headers['x-user-id'] as string,
-     *     debitAmount: req.body.tokens || 1
-     *   }),
-     *   whitelist: ['/api/generate', '/api/analyze', '/api/v1/*']
-     * }));
-     *
-     * // Exclude specific endpoints from tracking
-     * app.use(scrawn.middlewareEventConsumer({
-     *   extractor: (req) => ({
-     *     userId: req.user.id,
-     *     debitAmount: 1
-     *   }),
-     *   blacklist: ['/health', '/api/collect-payment', '/internal/**', '**.tmp']
-     * }));
-     * ```
-     */
-    middlewareEventConsumer(config: MiddlewareEventConfig): (req: MiddlewareRequest, res: MiddlewareResponse, next: MiddlewareNext) => Promise<void>;
-    /**
-     * Collect payment by creating a checkout link for a user.
-     *
-     * Generates a payment checkout link for the specified user via the Scrawn payment service.
-     * The checkout link can be used to direct users to complete their payment.
-     *
-     * @param userId - Unique identifier of the user to collect payment from
-     * @returns A promise that resolves to the checkout link URL
-     * @throws Error if the gRPC call fails or if authentication is invalid
-     *
-     * @example
-     * ```typescript
-     * const checkoutLink = await scrawn.collectPayment('user_abc123');
-     * // Returns: 'https://checkout.scrawn.dev/...'
-     * // Redirect user to this URL to complete payment
-     * ```
-     */
-    collectPayment(userId: string): Promise<string>;
-    /**
-     * Internal method to consume and process an event.
-     *
-     * This method:
-     * 1. Validates authentication
-     * 2. Fetches/caches credentials
-     * 3. Executes any pre-run hooks
-     * 4. Processes the event via gRPC call to RegisterEvent
-     *
-     * @param payload - Event payload data
-     * @param authMethodName - Name of the auth method to use (must be in AuthRegistry)
-     * @param eventType - Type of event for categorization (RAW or MIDDLEWARE_CALL)
-     * @returns A promise that resolves when the event is processed
-     * @throws Error if auth method is not registered or gRPC call fails
-     *
-     * @internal
-     */
-    private consumeEvent;
-}
-//# sourceMappingURL=scrawn.d.ts.map

package/dist/core/scrawn.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scrawn.d.ts","sourceRoot":"","sources":["../../src/core/scrawn.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,cAAc,EACd,qBAAqB,EACtB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAgC,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAYpF;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,MAAM;IACjB,kEAAkE;IAClE,OAAO,CAAC,WAAW,CAAuD;IAE1E;;;OAGG;IACH,OAAO,CAAC,SAAS,CAA6C;IAE9D,8CAA8C;IAC9C,OAAO,CAAC,MAAM,CAA2B;IAEzC,iDAAiD;IACjD,OAAO,CAAC,UAAU,CAAa;IAE/B;;;;;;;;;;;;;;;OAeG;gBACS,MAAM,EAAE;QAAE,MAAM,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;IAWzE;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,kBAAkB;IAO1B;;;;;;;;;;;;;;;;OAgBG;YACW,WAAW;IAmBzB;;;;;;;;;;;;;;;;;;;OAmBG;IACG,oBAAoB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAWhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmDG;IACH,uBAAuB,CAAC,MAAM,EAAE,qBAAqB,IACrC,KAAK,iBAAiB,EAAE,KAAK,kBAAkB,EAAE,MAAM,cAAc;IAkDrF;;;;;;;;;;;;;;;;OAgBG;IACG,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IA6BrD;;;;;;;;;;;;;;;;OAgBG;YACW,YAAY;CA8C3B"}