import { type Result } from '@conduit-client/utils';
import type { NamedPubSubService } from '@conduit-client/service-pubsub/v1';
import type { InstrumentationAttributes, NamedInstrumentationService } from '@conduit-client/service-instrumentation/v1';
import type { NamedCacheControllerService } from '@conduit-client/service-cache-control/v1';
import type { Key, CanonicalCacheControlMetadata, ReadonlyCache, CacheEntry, Cache } from '@conduit-client/service-cache/v1';
export interface NormalizedLink {
    type: 'link';
    linkedKey: Key;
}
type UnknownError = {
    type: 'unknown';
    error: Error;
};
/**
 * An error that occurs when a type tries to read from the cache, and the cache metadata does
 * not match the current type
 */
type IncorrectTypeError = {
    type: 'incorrectType';
    expectedType: string;
    actualType: string;
};
/**
 * An error that occurs when a type tries to read from the cache and data is missing
 */
type MissingDataError = {
    type: 'missingData';
    namespace: string;
    typeName: string;
    data: unknown;
};
/**
 * A union of errors that can be returned during the write process
 */
export type WriteErrors = Array<UnknownError>;
/**
 * A union of errors that can be returned during the read process
 */
export type ReadErrors = Array<UnknownError | IncorrectTypeError | MissingDataError>;
export type ReadResult<Data> = Result<Data, ReadErrors>;
export type WriteResult<Data> = Result<Data, WriteErrors>;
/**
 * A Type defines a collection of functions associated with a particular
 * data type. Types are not normalized but may contain normalized data.
 *
 * @typeParam Data TypeScript type that corresponds to the data
 * @typeParam NormalizedData TypeScript type that corresponds to the normalized data
 * @typeParam NormalizeInputData TypeScript type that corresponds to the data that the normalize method expects as input. Defaults to the same as Data
 */
export type TypeRepository<Data, ReadInput, WriteResponse, WriteInput> = {
    readonly namespace: string;
    readonly typeName: string;
    equals(x: Data, y: Data): boolean;
    /**
     * Normalizes data for storage.
     */
    write(cache: Cache, input: WriteInput): WriteResult<WriteResponse>;
    /**
     * De-normalizes a Type's data. A type could normalize into a Link, or return Data to the caller.
     * A caller must not be relying on the referenced type being normalized or not.
     * If denormalization fails, it will return undefined.
     */
    read(cache: ReadonlyCache, input: ReadInput): ReadResult<Data>;
};
/**
 * An InvalidatableType defines an invalidate function that takes a generic input,
 * and returns a promise that resolves when the invalidation is complete
 *
 * @typeParam T is another type to extend
 * @typeParam InvalidateInput is the input to run an invalidation
 */
export type Invalidatable<T extends TypeRepository<any, any, any, any>, InvalidateInput> = T & {
    /**
     *
     * @param configs Partial KeyConfigs for this Type (partial KeyConfig treats missing parts as wildcard)
     */
    invalidate(configs: InvalidateInput[]): Promise<void>;
};
/**
 * A QueryableType defines a collection of functions associated with a particular
 * data type that gets its own cache entry.
 *
 * @typeParam Data TypeScript type that corresponds to the data
 * @typeParam KeyConfig TypeScript type for the inputs needed to construct
 *   a Key for the data
 * @typeParam NormalizeInputData TypeScript type that corresponds to the data that the normalize method expects as input. Defaults to the same as Data
 */
export type Queryable<T extends TypeRepository<any, any, any, any>, QueryInput> = T & {
    /**
     *
     * @param cache The cache to run the query against
     * @param query The query to run
     */
    query(cache: Cache, query: QueryInput): ReadResult<DataOf<T>>;
};
export type DataOf<T extends TypeRepository<any, any, any, any>> = T extends TypeRepository<infer Data, any, any, any> ? Data : never;
export type ReadInputOf<T extends TypeRepository<any, any, any, any>> = T extends TypeRepository<any, infer ReadInput, any, any> ? ReadInput : never;
export type WriteResponseOf<T extends TypeRepository<any, any, any, any>> = T extends TypeRepository<any, any, infer WriteResponse, any> ? WriteResponse : never;
export type WriteResultOf<T extends TypeRepository<any, any, any, any>> = WriteResult<WriteResponseOf<T>>;
export type WriteInputOf<T extends TypeRepository<any, any, any, any>> = T extends TypeRepository<any, any, any, infer WriteInput> ? WriteInput : never;
export type InvalidateInputOf<T extends TypeRepository<any, any, any, any>> = T extends Invalidatable<TypeRepository<any, any, any, any>, infer InvalidateInput> ? InvalidateInput : never;
/**
 * A utility method for ensuring that a given entry in the cache matches a type based on namespace and name information
 * @param cacheEntry the cache entry to validate against
 * @param type the type to validate the cache entry against
 * @returns
 */
export declare function isCacheEntryForType(cacheEntry: CacheEntry<unknown>, type: TypeRepository<any, any, any, any>): boolean;
export type KeyParamsOf<T> = T extends IdentifiableTypeRepository<any, any, infer KeyParams, Record<string, unknown>, Record<string, unknown>> ? KeyParams : never;
export type WriteInput<Data, Extension = Record<string, unknown>> = {
    data: Data;
} & Extension;
export type NormalizeDataInput<Data, NormalizedData, Extension extends Record<string, unknown> = Record<string, unknown>> = WriteInput<Data, Extension & {
    existingNormalizedData?: NormalizedData;
}>;
export type ReadInput<Extension extends Record<string, unknown> = Record<string, unknown>> = {
    normalizedData: NormalizedLink;
} & Extension;
export type ReadByKeyParamsInput<KeyParams> = {
    keyParams: KeyParams;
};
export type DenormalizeInput<Extension extends Record<string, unknown> = Record<string, unknown>> = Extension & {
    key: Key;
};
export type DenormalizeDataInput<NormalizedData, Extension extends Record<string, unknown> = Record<string, unknown>> = Extension & {
    normalizedData: NormalizedData;
};
export type KeyParamQuery<KeyParams, ReadInputExtension> = {
    type: 'keyParams';
    keyParams: KeyParams;
} & ReadInputExtension;
export type QueryFor<T> = T extends Queryable<TypeRepository<any, any, any, any>, infer Query> ? Query : never;
/**
 * An abstract base class that implements Type, defining additional abstract properties and methods
 * for building a key for a given set of parameters, and defining the canonical cache control metadata
 * for any data written
 */
export declare abstract class IdentifiableTypeRepository<Data, NormalizedData, KeyParams, ReadInputExtension extends Record<string, unknown> = Record<string, unknown>, WriteInputExtension extends Record<string, unknown> = Record<string, unknown>, Query extends KeyParamQuery<KeyParams, ReadInputExtension> = KeyParamQuery<KeyParams, ReadInputExtension>> implements Queryable<TypeRepository<Data, ReadInput<ReadInputExtension>, NormalizedLink, WriteInput<Data, WriteInputExtension>>, Query> {
    protected services: {};
    constructor(services: {});
    abstract readonly cacheControl: CanonicalCacheControlMetadata;
    abstract readonly namespace: string;
    abstract readonly typeName: string;
    protected abstract denormalizeData(cache: ReadonlyCache, input: DenormalizeDataInput<NormalizedData, ReadInput<ReadInputExtension>>): Result<Data, ReadErrors>;
    protected abstract normalizeData(cache: Cache, input: NormalizeDataInput<Data, NormalizedData, WriteInputExtension & {
        existingNormalizedData?: NormalizedData;
    }>): Result<NormalizedData, WriteErrors>;
    get cacheMetadata(): {
        cacheControl: {
            type: "max-age";
            maxAge: number;
        } | {
            type: "stale-while-revalidate";
            maxAge: number;
            staleTime: number;
        } | {
            type: "no-cache";
        } | {
            type: "no-store";
        };
        type: {
            namespace: string;
            name: string;
        };
    };
    buildKey(params: KeyParams): Key;
    abstract buildKeyParams(input: WriteInput<Data, WriteInputExtension>): KeyParams;
    write(cache: Cache, input: WriteInput<Data, WriteInputExtension>): WriteResult<NormalizedLink>;
    protected validateEntry(entry: CacheEntry<unknown>): Result<undefined, ReadErrors>;
    query(cache: Cache, query: Query): ReadResult<Data>;
    read(cache: ReadonlyCache, input: ReadInput<ReadInputExtension>): Result<Data, ReadErrors>;
    denormalize(cache: ReadonlyCache, input: DenormalizeInput<ReadInput<ReadInputExtension>>): Result<Data, ReadErrors>;
    equals(x: Data, y: Data): boolean;
    buildMissingDataError(): MissingDataError;
}
/**
 * An abstract base class that extends IdentifiableType, adding the additional constraint that the
 * only data required to write to the cache is an instance of the data itself, i.e. the identity of
 * the data lives inside the data
 */
export declare abstract class SelfIdentifiableTypeRepository<Data, NormalizedData, KeyParams, ReadInputExtension extends Record<string, unknown> = Record<string, unknown>, WriteInputExtension extends Record<string, unknown> = Record<string, unknown>> extends IdentifiableTypeRepository<Data, NormalizedData, KeyParams, ReadInputExtension, WriteInputExtension> {
}
/**
 * Adds flat positional keying (keySchema), keySchema-based buildKey, and invalidate/evict
 * to IdentifiableTypeRepository. Key params are supplied externally (e.g. from request
 * config) — this class makes NO claim that identity lives in the data. KeyParams must be a
 * flat object (scalars, scalar arrays, or stable-stringifiable objects). Provides
 * invalidation + key building 'for free'.
 */
export declare abstract class FlattenedKeyIdentifiableTypeRepository<Data, NormalizedData, KeyParams extends FlattenedKeyParams, ReadInputExtension extends Record<string, unknown> = Record<string, unknown>, WriteInputExtension extends Record<string, unknown> = Record<string, unknown>> extends IdentifiableTypeRepository<Data, NormalizedData, KeyParams, ReadInputExtension, WriteInputExtension> implements Invalidatable<IdentifiableTypeRepository<Data, NormalizedData, KeyParams, ReadInputExtension, WriteInputExtension>, Partial<KeyParams>> {
    protected services: NamedCacheControllerService & NamedPubSubService & Partial<NamedInstrumentationService>;
    instrumentationAttributes: InstrumentationAttributes | undefined;
    constructor(services: NamedCacheControllerService & NamedPubSubService & Partial<NamedInstrumentationService>);
    abstract readonly keySchema: string[];
    invalidate(configs: Partial<KeyParams>[]): Promise<void>;
    protected collectInstrumentation(duration: number, type: 'invalidate' | 'evict'): void;
    evict(configs: Partial<KeyParams>[]): Promise<void>;
    private setupCacheOperation;
    /**
     * Shared implementation for cache operations (invalidate/evict)
     * @param configs - Key configurations to match
     * @param cacheUpdateType - Type of cache update to perform
     * @param eventType - Type of event to publish
     */
    private runCacheOperation;
    buildKey(config: KeyParams): Key;
}
/**
 * Flat-keyed identifiable type whose identity lives inside the data itself
 * (self-identifiable). Behaviorally identical to FlattenedKeyIdentifiableTypeRepository;
 * the distinction is a semantic marker for generators that derive keyParams from data.
 */
export declare abstract class FlattenedKeySelfIdentifiableTypeRepository<Data, NormalizedData, KeyParams extends FlattenedKeyParams, ReadInputExtension extends Record<string, unknown> = Record<string, unknown>, WriteInputExtension extends Record<string, unknown> = Record<string, unknown>> extends FlattenedKeyIdentifiableTypeRepository<Data, NormalizedData, KeyParams, ReadInputExtension, WriteInputExtension> {
}
type ScalarKeyValue = string | number | boolean | null | undefined;
type FlattenedKeyParams = Record<string, ScalarKeyValue | ScalarKeyValue[] | object>;
export declare function buildNamespacedTypeKey(namespace: string, typeName: string, keyConfig: FlattenedKeyParams, keySchema: string[]): string;
export declare function buildRegexForNamespacedKeys(namespace: string, typeName: string, partialKeyConfigs: Array<FlattenedKeyParams>, keySchema: string[]): RegExp;
export declare function extractReadWriteData<Data, Error>(result: Result<Data, Error[]>, errorCollector: Error[]): Data | undefined;
export declare function buildReadWriteResult<Data, Errors extends WriteErrors | ReadErrors>(data: unknown, errors: Errors): Result<Data, Errors>;
export type UnionRepresentation<Discriminator extends string, Data> = {
    discriminator: Discriminator;
    data: Data;
};
export type DiscriminatorMap<Discriminator extends string, Data, Normalized> = {
    [k in Discriminator]: {
        data: Data;
        normalized: Normalized;
    };
};
export type NormalizedRepresentationOf<M extends DiscriminatorMap<string, unknown, unknown>> = M extends DiscriminatorMap<infer D, unknown, unknown> ? {
    [k in D]: UnionRepresentation<k, M[k]['normalized']>;
}[D] : never;
export type DenormalizeMapOf<M extends DiscriminatorMap<string, unknown, unknown>> = M extends DiscriminatorMap<infer D, unknown, unknown> ? {
    [k in D]: (normalized: M[k]['normalized']) => M[k]['data'];
} : never;
export type UnionDataOf<M extends DiscriminatorMap<string, unknown, unknown>> = M extends DiscriminatorMap<string, infer D, unknown> ? D : never;
export type DiscriminatorOf<M extends DiscriminatorMap<string, unknown, unknown>> = M extends DiscriminatorMap<infer D, unknown, unknown> ? D : never;
export type DiscriminatorNormalizeFunctionsMap<M extends DiscriminatorMap<string, unknown, unknown>> = M extends DiscriminatorMap<infer D, unknown, unknown> ? {
    [k in D]: {
        test: (data: M[D]['data']) => boolean | Result<boolean, Error[]>;
        normalize: (data: M[k]['data']) => M[k]['normalized'];
    };
} : never;
/**
 *
 * @param normalized The normalized data representation, including the discriminator value
 * @param denormalizeMap A map of discriminator -> denormalize functions to be used based on the datas discriminator
 * @returns
 */
export declare function denormalizeUnionRepresentation<M extends DiscriminatorMap<string, unknown, unknown>>(normalized: NormalizedRepresentationOf<M>, denormalizeMap: DenormalizeMapOf<M>): UnionDataOf<M>;
/**
 *
 * @param data The canonical/denormalized data representation
 * @param normalizeTestMap A map of discriminator to test method which return a boolean indicating if the data adheres to this "discriminator"
 * and a normalize function to call if the data matches this discriminator
 * @returns
 */
export declare function normalizeUnionRepresentation<M extends DiscriminatorMap<string, unknown, unknown>>(data: UnionDataOf<M>, normalizeTestMap: DiscriminatorNormalizeFunctionsMap<M>): NormalizedRepresentationOf<M>;
export {};