@timeback/clr 0.1.0

package/dist/lib/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Internal Library Exports
+ *
+ * @internal
+ */
+export { resolveToProvider } from './resolve';
+export { Transport } from './transport';
+export type { ResolvedConfig } from '@timeback/internal-client-infra';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lib/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAEvC,YAAY,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAA"}

package/dist/lib/resolve.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Provider Resolution
+ *
+ * CLR-specific wrapper around the generic provider resolver.
+ *
+ * @internal
+ */
+import type { ProviderRegistry } from '@timeback/internal-client-infra';
+import type { ClrClientConfig, ClrResolvedProvider } from '../types';
+/**
+ * Resolve CLR client config to a TimebackProvider.
+ *
+ * @param config - Client configuration
+ * @param registry - Provider registry for platform/env resolution
+ * @returns Resolved provider or transport
+ * @throws {Error} If configuration is invalid or incomplete
+ *
+ * @internal
+ */
+export declare function resolveToProvider(config: ClrClientConfig, registry?: ProviderRegistry): ClrResolvedProvider;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/lib/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../src/lib/resolve.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AASH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAA;AACvE,OAAO,KAAK,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAEpE;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAChC,MAAM,EAAE,eAAe,EACvB,QAAQ,GAAE,gBAA4C,GACpD,mBAAmB,CAMrB"}

package/dist/lib/transport.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Transport Layer
+ *
+ * HTTP transport for CLR API communication.
+ */
+import { BaseTransport } from '@timeback/internal-client-infra';
+import type { ClrPaths } from '@timeback/internal-client-infra';
+import type { ClrTransportConfig } from '../types';
+/**
+ * HTTP transport layer for CLR API communication.
+ *
+ * CLR uses the IMS Global error format, which is handled by the
+ * base transport's built-in IMS error parsing. No custom pagination
+ * is needed since CLR endpoints don't return paginated results.
+ */
+export declare class Transport extends BaseTransport {
+    /** API path profiles for CLR operations */
+    readonly paths: ClrPaths;
+    constructor(config: ClrTransportConfig);
+}
+//# sourceMappingURL=transport.d.ts.map

package/dist/lib/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../src/lib/transport.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAA;AAI/D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAA;AAC/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAElD;;;;;;GAMG;AACH,qBAAa,SAAU,SAAQ,aAAa;IAC3C,2CAA2C;IAC3C,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAA;IAExB,YAAY,MAAM,EAAE,kBAAkB,EAGrC;CACD"}

package/dist/public-types.d.ts

@@ -0,0 +1,376 @@
+/**
+ * CLR Credential Types
+ *
+ * Types for the Comprehensive Learner Record (CLR) v2.0 Verifiable Credential model.
+ * Based on the IMS Global CLR v2.0 specification.
+ */
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// ENUMS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Types of achievements that can be represented in a CLR credential.
+ *
+ * Defined by the IMS Global CLR v2.0 specification.
+ * Custom extensions are supported via the `ext:` prefix.
+ */
+type AchievementType =
+	| 'Achievement'
+	| 'ApprenticeshipCertificate'
+	| 'Assessment'
+	| 'Assignment'
+	| 'AssociateDegree'
+	| 'Award'
+	| 'Badge'
+	| 'BachelorDegree'
+	| 'Certificate'
+	| 'CertificateOfCompletion'
+	| 'Certification'
+	| 'CommunityService'
+	| 'Competency'
+	| 'Course'
+	| 'CoCurricular'
+	| 'Degree'
+	| 'Diploma'
+	| 'DoctoralDegree'
+	| 'Fieldwork'
+	| 'GeneralEducationDevelopment'
+	| 'JourneymanCertificate'
+	| 'LearningProgram'
+	| 'License'
+	| 'Membership'
+	| 'ProfessionalDoctorate'
+	| 'QualityAssuranceCredential'
+	| 'MasterCertificate'
+	| 'MasterDegree'
+	| 'MicroCredential'
+	| 'ResearchDoctorate'
+	| 'SecondarySchoolDiploma'
+	| (string & {})
+
+/**
+ * Types of associations between achievements or credentials.
+ */
+type AssociationType =
+	| 'exactMatchOf'
+	| 'isChildOf'
+	| 'isParentOf'
+	| 'isPartOf'
+	| 'isPeerOf'
+	| 'isRelatedTo'
+	| 'precedes'
+	| 'replacedBy'
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// SHARED TYPES
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Image reference following the IMS Global Image model.
+ */
+interface ClrImage {
+	/** The URI or Data URI of the image. */
+	id: string
+	/** MUST be the IRI 'Image'. */
+	type: 'Image'
+	/** The caption for the image. */
+	caption?: string
+}
+
+/**
+ * Profile representing an issuer or creator of a credential.
+ *
+ * Used for both the top-level issuer and achievement creators.
+ */
+interface ClrProfile {
+	/** URI identifier for the profile. */
+	id: string
+	/** Type identifiers (e.g., ['Profile']). */
+	type: string[]
+	/** Display name of the profile. */
+	name?: string
+	/** URL of the profile's website. */
+	url?: string
+	/** Phone number for the profile. */
+	phone?: string
+	/** Description of the profile. */
+	description?: string
+	/** Image associated with the profile. */
+	image?: ClrImage
+	/** Email address for the profile. */
+	email?: string
+}
+
+/**
+ * Cryptographic proof ensuring credential integrity and authenticity.
+ *
+ * Supports DataIntegrityProof, JsonWebSignature2020, and other proof types.
+ */
+interface ClrProof {
+	/** The proof type (e.g., 'DataIntegrityProof', 'JsonWebSignature2020'). */
+	type: string
+	/** The purpose of the proof (e.g., 'assertionMethod'). */
+	proofPurpose: string
+	/** URI of the verification method used to create the proof. */
+	verificationMethod: string
+	/** ISO 8601 datetime when the proof was created. */
+	created: string
+	/** The proof value (e.g., base64-encoded signature). */
+	proofValue: string
+	/** The cryptographic suite used (e.g., 'eddsa-rdfc-2022'). */
+	cryptosuite?: string
+}
+
+/**
+ * Schema reference for validating credentials.
+ */
+interface ClrCredentialSchema {
+	/** URI of the credential schema. */
+	id: string
+	/** Schema validator type. */
+	type: '1EdTechJsonSchemaValidator2019'
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// ACHIEVEMENT TYPES
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Criteria for earning an achievement.
+ */
+interface AchievementCriteria {
+	/** The URI of a webpage that describes the criteria. */
+	id?: string
+	/** A narrative of what is needed to earn the achievement. */
+	narrative?: string
+}
+
+/**
+ * An achievement that a learner has earned.
+ *
+ * Represents a competency, course completion, badge, or other accomplishment.
+ */
+interface Achievement {
+	/** URI identifier for the achievement. */
+	id: string
+	/** Type identifiers (e.g., ['Achievement']). */
+	type: string[]
+	/** Display name of the achievement. */
+	name: string
+	/** Description of the achievement. */
+	description: string
+	/** Criteria for earning the achievement. */
+	criteria: AchievementCriteria
+	/** Image associated with the achievement. */
+	image?: ClrImage
+	/** Classification of the achievement. */
+	achievementType?: AchievementType
+	/** The profile of the entity that created the achievement. */
+	creator?: ClrProfile
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// IDENTITY TYPES
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Identity object for the credential subject.
+ *
+ * Used to identify the learner, optionally with hashed identity for privacy.
+ */
+interface IdentityObject {
+	/** MUST be 'IdentityObject'. */
+	type: 'IdentityObject'
+	/** The identity hash (or plain value if not hashed). */
+	identityHash: string
+	/** The type of identity (e.g., 'emailAddress', 'sourcedId'). */
+	identityType: string
+	/** Whether the identityHash is hashed. */
+	hashed: boolean
+	/** Salt used for hashing, if applicable. */
+	salt?: string
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// ASSOCIATION TYPES
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Association between two achievements or credentials.
+ */
+interface Association {
+	/** MUST be 'Association'. */
+	type: 'Association'
+	/** The type of association. */
+	associationType: AssociationType
+	/** URI of the source entity. */
+	sourceId: string
+	/** URI of the target entity. */
+	targetId: string
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// VERIFIABLE CREDENTIAL (NESTED)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Credential subject for a nested verifiable credential.
+ */
+interface NestedCredentialSubject {
+	/** URI identifier for the subject. */
+	id?: string
+}
+
+/**
+ * A verifiable credential nested within a CLR.
+ *
+ * Represents individual assertions (e.g., AchievementCredentials,
+ * OpenBadgeCredentials) packaged inside the CLR.
+ */
+interface VerifiableCredential {
+	/** JSON-LD context URIs. */
+	'@context': string[]
+	/** URI identifier for the credential. */
+	id: string
+	/** Type identifiers (e.g., ['VerifiableCredential', 'AchievementCredential']). */
+	type: string[]
+	/** The issuer of this credential. */
+	issuer: ClrProfile
+	/** ISO 8601 datetime from which the credential is valid. */
+	validFrom: string
+	/** ISO 8601 datetime until which the credential is valid. */
+	validUntil?: string
+	/** The subject of the credential. */
+	credentialSubject: NestedCredentialSubject
+	/** Cryptographic proofs for this credential. */
+	proof?: ClrProof[]
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CREDENTIAL SUBJECT
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * The subject of a CLR credential.
+ *
+ * Contains the learner's identity, achievements, nested credentials,
+ * and associations between them.
+ */
+interface ClrCredentialSubject {
+	/** URI identifier for the credential subject (the learner). */
+	id?: string
+	/** Type identifiers (e.g., ['ClrSubject']). */
+	type: string[]
+	/** Identity objects for the learner. */
+	identifier?: IdentityObject[]
+	/** Achievements earned by the learner. */
+	achievement?: Achievement[]
+	/** Individual verifiable credentials packaged in the CLR. */
+	verifiableCredential: VerifiableCredential[]
+	/** Associations between achievements or credentials. */
+	association?: Association[]
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CLR CREDENTIAL
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * A Comprehensive Learner Record (CLR) v2.0 Verifiable Credential.
+ *
+ * The top-level data structure representing a learner's full set of
+ * achievements issued by one or more learning providers. The platform
+ * acts as the publisher, digitally signing the CLR to ensure authenticity.
+ *
+ * Required fields for upsert: `@context`, `id`, `type`, `issuer`, `name`,
+ * `validFrom`, `credentialSubject`.
+ */
+interface ClrCredential {
+	/** JSON-LD context URIs. */
+	'@context': string[]
+	/** URI identifier for the CLR credential. */
+	id: string
+	/** Type identifiers (e.g., ['VerifiableCredential', 'ClrCredential']). */
+	type: string[]
+	/** The issuer (publisher) of the CLR. */
+	issuer: ClrProfile
+	/** Display name of the CLR. */
+	name: string
+	/** Description of the CLR. */
+	description?: string
+	/** ISO 8601 datetime from which the CLR is valid. */
+	validFrom: string
+	/** ISO 8601 datetime until which the CLR is valid. */
+	validUntil?: string
+	/** The learner and their achievements/credentials. */
+	credentialSubject: ClrCredentialSubject
+	/** Cryptographic proofs added by the platform. */
+	proof?: ClrProof[]
+	/** Schema references for credential validation. */
+	credentialSchema?: ClrCredentialSchema[]
+}
+
+/**
+ * CLR Discovery Types
+ *
+ * Types for the CLR v2.0 API discovery endpoint.
+ */
+
+/**
+ * Response from the CLR discovery endpoint.
+ *
+ * Returns the OpenAPI 3.0 specification for the CLR v2.0 API,
+ * including available endpoints, OAuth2 flows, and supported scopes.
+ * This is a public endpoint (no auth required).
+ */
+type DiscoveryResponse = Record<string, unknown>
+
+type output<T> = T extends {
+    _zod: {
+        output: any;
+    };
+} ? T["_zod"]["output"] : unknown;
+
+/**
+ * CLR Schemas
+ *
+ * Zod schemas for the CLR (Comprehensive Learner Record) v2.0 API.
+ */
+
+
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CLR CREDENTIAL (TOP-LEVEL)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Schema for upserting a CLR credential.
+ *
+ * Validates the required structure per the CLR v2.0 specification:
+ * - `@context`: non-empty array of JSON-LD context URIs
+ * - `id`: credential URI
+ * - `type`: non-empty array of type identifiers
+ * - `issuer`: profile with required `id` and `type`
+ * - `name`: display name
+ * - `validFrom`: ISO datetime string
+ * - `credentialSubject`: must include `type` and at least one `verifiableCredential`
+ */
+declare const ClrCredentialInput = z.object({
+	'@context': NonEmptyStringArray,
+	id: NonEmptyString,
+	type: NonEmptyStringArray,
+	issuer: ClrProfileSchema,
+	name: NonEmptyString,
+	description: z.string().optional(),
+	validFrom: NonEmptyString,
+	validUntil: z.string().optional(),
+	credentialSubject: ClrCredentialSubjectSchema,
+	proof: z.array(ClrProofSchema).optional(),
+	credentialSchema: z.array(ClrCredentialSchemaSchema).optional(),
+})
+
+type ClrCredentialInput = output<typeof ClrCredentialInput>
+
+export { ClrCredentialInput };
+export type { Achievement, AchievementCriteria, AchievementType, Association, AssociationType, ClrCredential, ClrCredentialSchema, ClrCredentialSubject, ClrImage, ClrProfile, ClrProof, DiscoveryResponse, IdentityObject, NestedCredentialSubject, VerifiableCredential };

package/dist/public-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-types.d.ts","sourceRoot":"","sources":["../src/public-types.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAA;AAE7C,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA"}

package/dist/resources/credentials.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Credentials Resource
+ *
+ * Manage CLR (Comprehensive Learner Record) credentials.
+ */
+import type { ClrCredential, ClrTransportLike } from '../types';
+/**
+ * Credentials resource for CLR credential management.
+ *
+ * Provides the ability to upsert verifiable CLR credentials.
+ * The platform acts as the publisher, digitally signing credentials
+ * to ensure their authenticity and integrity.
+ */
+export declare class CredentialsResource {
+    private readonly transport;
+    constructor(transport: ClrTransportLike);
+    /**
+     * Upsert a Comprehensive Learner Record (CLR) credential.
+     *
+     * Creates a new credential or updates an existing one based on the credential ID.
+     * The platform will digitally sign the credential, adding a cryptographic proof
+     * to ensure authenticity.
+     *
+     * @param credential - The CLR credential to upsert
+     * @returns The upserted credential with platform-added proof
+     *
+     * @example
+     * ```typescript
+     * const result = await client.credentials.upsert({
+     *   '@context': [
+     *     'https://www.w3.org/ns/credentials/v2',
+     *     'https://purl.imsglobal.org/spec/clr/v2p0/context-2.0.1',
+     *   ],
+     *   id: 'urn:uuid:example-clr-id',
+     *   type: ['VerifiableCredential', 'ClrCredential'],
+     *   issuer: {
+     *     id: 'https://example.edu',
+     *     type: ['Profile'],
+     *     name: 'Example University',
+     *   },
+     *   name: 'Student Transcript',
+     *   validFrom: '2024-01-01T00:00:00Z',
+     *   credentialSubject: {
+     *     type: ['ClrSubject'],
+     *     verifiableCredential: [
+     *       // nested credentials...
+     *     ],
+     *   },
+     * })
+     * ```
+     */
+    upsert(credential: ClrCredential): Promise<ClrCredential>;
+}
+//# sourceMappingURL=credentials.d.ts.map

package/dist/resources/credentials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credentials.d.ts","sourceRoot":"","sources":["../../src/resources/credentials.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAE/D;;;;;;GAMG;AACH,qBAAa,mBAAmB;IACnB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAAtC,YAA6B,SAAS,EAAE,gBAAgB,EAAI;IAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,MAAM,CAAC,UAAU,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAWxD;CACD"}

package/dist/resources/discovery.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Discovery Resource
+ *
+ * CLR v2.0 API discovery endpoint.
+ */
+import type { ClrTransportLike, DiscoveryResponse } from '../types';
+/**
+ * Discovery resource for CLR API capabilities.
+ *
+ * Provides access to the CLR v2.0 API discovery endpoint,
+ * which returns the OpenAPI specification including available
+ * endpoints, OAuth2 flows, and supported scopes.
+ *
+ * NOTE: The CLR v2.0 spec declares this endpoint as public (`security: []`),
+ * but the BeyondAI implementation enforces OAuth authentication. This client
+ * sends credentials on all requests, so this is handled transparently.
+ */
+export declare class DiscoveryResource {
+    private readonly transport;
+    constructor(transport: ClrTransportLike);
+    /**
+     * Get CLR v2.0 API discovery information.
+     *
+     * Returns the OpenAPI 3.0 specification for the CLR v2.0 API,
+     * allowing clients to dynamically discover the service's capabilities.
+     *
+     * NOTE: Despite the spec declaring this as a public endpoint, the
+     * BeyondAI API requires authentication. An authenticated transport
+     * is required.
+     *
+     * @returns Discovery information (OpenAPI spec object)
+     *
+     * @example
+     * ```typescript
+     * const discovery = await client.discovery.get()
+     * console.log(discovery) // OpenAPI 3.0 spec
+     * ```
+     */
+    get(): Promise<DiscoveryResponse>;
+}
+//# sourceMappingURL=discovery.d.ts.map

package/dist/resources/discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../src/resources/discovery.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAEnE;;;;;;;;;;GAUG;AACH,qBAAa,iBAAiB;IACjB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAAtC,YAA6B,SAAS,EAAE,gBAAgB,EAAI;IAE5D;;;;;;;;;;;;;;;;;OAiBG;IACH,GAAG,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAIhC;CACD"}

package/dist/resources/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * CLR Resources
+ */
+export { CredentialsResource } from './credentials';
+export { DiscoveryResource } from './discovery';
+//# sourceMappingURL=index.d.ts.map

package/dist/resources/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resources/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAA;AACnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA"}

package/dist/types/client.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Client Configuration Types
+ */
+import type { ClientConfig, ClrPaths, ProviderClientConfig, RequestOptions, ResolvedProvider, TransportConfigWithTokenProvider, TransportOnlyConfig } from '@timeback/internal-client-infra';
+/**
+ * Re-export vital config types for SDK users.
+ */
+export type { Environment, EnvAuth, ExplicitAuth, Platform } from '@timeback/internal-client-infra';
+/**
+ * Transport interface for CLR client.
+ *
+ * Extends base transport requirements with CLR-specific paths.
+ * Required when using transport mode with ClrClient.
+ */
+export interface ClrTransportLike {
+    /** Base URL of the API */
+    baseUrl: string;
+    /** API path profiles for CLR operations */
+    paths: ClrPaths;
+    /** Make an authenticated request */
+    request<T>(path: string, options?: RequestOptions): Promise<T>;
+}
+/**
+ * All supported CLR client configuration types.
+ *
+ * Supports four modes:
+ * - **Provider mode**: `{ provider: TimebackProvider }` — pre-built provider with token sharing
+ * - **Environment mode**: `{ platform?, env, auth }` — Timeback hosted APIs
+ * - **Explicit mode**: `{ baseUrl, auth: { authUrl } }` — custom API URLs
+ * - **Transport mode**: `{ transport }` — custom transport with paths
+ */
+export type ClrClientConfig = ClientConfig | TransportOnlyConfig<ClrTransportLike> | ProviderClientConfig;
+/**
+ * Configuration for CLR transport.
+ */
+export interface ClrTransportConfig extends TransportConfigWithTokenProvider {
+    /** API path profiles for CLR operations */
+    paths: ClrPaths;
+}
+/**
+ * Resolved provider type for CLR client.
+ */
+export type ClrResolvedProvider = ResolvedProvider<ClrTransportLike>;
+/**
+ * Instance type of ClrClient.
+ */
+export type ClrClientInstance = InstanceType<typeof import('../client').ClrClient>;
+//# sourceMappingURL=client.d.ts.map

package/dist/types/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/types/client.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EACX,YAAY,EACZ,QAAQ,EACR,oBAAoB,EACpB,cAAc,EACd,gBAAgB,EAChB,gCAAgC,EAChC,mBAAmB,EACnB,MAAM,iCAAiC,CAAA;AAExC;;GAEG;AACH,YAAY,EAAE,WAAW,EAAE,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAA;AAEnG;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAChC,0BAA0B;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,2CAA2C;IAC3C,KAAK,EAAE,QAAQ,CAAA;IACf,oCAAoC;IACpC,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;CAC9D;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,eAAe,GACxB,YAAY,GACZ,mBAAmB,CAAC,gBAAgB,CAAC,GACrC,oBAAoB,CAAA;AAEvB;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,gCAAgC;IAC3E,2CAA2C;IAC3C,KAAK,EAAE,QAAQ,CAAA;CACf;AAED;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,gBAAgB,CAAC,gBAAgB,CAAC,CAAA;AAEpE;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,YAAY,CAAC,cAAc,WAAW,EAAE,SAAS,CAAC,CAAA"}

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from '@timeback/types/protocols/clr';
+export * from './client';
+export type { ClrCredentialInput } from '@timeback/types/zod';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAA;AAC7C,cAAc,UAAU,CAAA;AAExB,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA"}

package/dist/types.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Subpath export for all entity types.
+ *
+ * @example
+ * ```typescript
+ * import type { ClrCredential, VerifiableCredential } from '@timeback/clr/types'
+ * ```
+ */
+export * from './types/index';
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,cAAc,eAAe,CAAA"}

package/dist/utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Utility Functions
+ *
+ * Internal utilities for the CLR client.
+ */
+/**
+ * Scoped logger for the CLR client.
+ * Only logs debug/info when DEBUG=1 or DEBUG=true.
+ */
+export declare const log: import("@timeback/internal-logger").Logger;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH;;;GAGG;AACH,eAAO,MAAM,GAAG,4CAA4B,CAAA"}