@cardstack/boxel-cli 0.2.0 → 0.3.0-unstable.13

package/bundled-types/base/card-api.d.ts

@@ -0,0 +1,513 @@
+import Modifier from 'ember-modifier';
+import GlimmerComponent from '@glimmer/component';
+import { type MenuItemOptions } from '@cardstack/boxel-ui/helpers';
+import { type BoxComponent } from './field-component';
+import { CardContextName, CardError, CodeRef, CommandContext, fields, fieldSerializer, fieldsUntracked, formats, getMenuItems, isBaseInstance, isFileDef, isField, localId, LocalPath, meta, primitive, realmURL, relativeTo, SingleCardDocument, type Format, type CardFields, type ResourceID, type LooseCardResource, type LooseSingleCardDocument, type CardDocument, type CardResourceMeta, type ResolvedCodeRef, type getCard, type getCards, type getCardCollection, type Store, type PrerenderedCardComponentSignature, type ErrorEntry, type Query, type QueryWithInterpolations, type QueryResultsMeta, CardResource, LooseLinkableResource, LooseSingleResourceDocument, type RuntimeDependencyTrackingContext, type RealmResourceIdentifier } from '@cardstack/runtime-common';
+import { ensureQueryFieldSearchResource } from './query-field-support';
+import { isSavedInstance } from './-private';
+import type { ComponentLike } from '@glint/template';
+import { deserialize, serialize, serializeCard, serializeFileDef, type DeserializeOpts, type JSONAPIResource, type JSONAPISingleResourceDocument, type SerializeOpts, getCardMeta } from './card-serialization';
+import { getDataBucket, getFieldDescription, getFields, isCard, peekAtField, realmContext, relationshipMeta } from './field-support';
+import { type GetMenuItemParams } from './menu-items';
+import { LinkableDocument, SingleFileMetaDocument } from '@cardstack/runtime-common/document-types';
+import type { FileMetaResource } from '@cardstack/runtime-common';
+export declare const BULK_GENERATED_ITEM_COUNT = 3;
+interface CardOrFieldTypeIconSignature {
+    Element: SVGSVGElement;
+}
+export type CardOrFieldTypeIcon = ComponentLike<CardOrFieldTypeIconSignature>;
+export { deserialize, getCardMeta, getDataBucket, getFieldDescription, getFields, peekAtField, isCard, isField, isFileDef, localId, meta, primitive, realmURL, relativeTo, relationshipMeta, serialize, serializeCard, serializeFileDef, ensureQueryFieldSearchResource, getStore, type BoxComponent, type DeserializeOpts, type GetMenuItemParams, type JSONAPISingleResourceDocument, type ResourceID, type SerializeOpts };
+export declare const useIndexBasedKey: unique symbol;
+export declare const fieldDecorator: unique symbol;
+export declare const queryableValue: unique symbol;
+export declare const formatQuery: unique symbol;
+export declare const realmInfo: unique symbol;
+export declare const emptyValue: unique symbol;
+export type BaseInstanceType<T extends BaseDefConstructor> = T extends {
+    [primitive]: infer P;
+} ? P : InstanceType<T>;
+type PartialFields<T> = {
+    [Property in keyof T]: Property extends symbol ? T[Property] : Property extends 'constructor' ? T[Property] : T[Property] | undefined;
+};
+export type PartialBaseInstanceType<T extends BaseDefConstructor> = T extends {
+    [primitive]: infer P;
+} ? P | null : PartialFields<InstanceType<T>> & {
+    [fields]: Record<string, BaseDefConstructor>;
+    [fieldsUntracked]: Record<string, BaseDefConstructor>;
+};
+export type FieldsTypeFor<T extends BaseDef> = {
+    [Field in keyof T]: BoxComponent & (T[Field] extends ArrayLike<unknown> ? BoxComponent[] : T[Field] extends BaseDef ? FieldsTypeFor<T[Field]> : unknown);
+};
+export { formats, type Format };
+export type FieldType = 'contains' | 'containsMany' | 'linksTo' | 'linksToMany';
+export type FieldConfiguration = Record<string, any>;
+export type ConfigurationInput<T> = FieldConfiguration | ((this: Readonly<T>) => FieldConfiguration | undefined);
+export type FieldFormats = {
+    ['fieldDef']: Format;
+    ['cardDef']: Format;
+};
+type Setter = (value: any) => void;
+export type SerializedFile<Extra extends object = {}> = {
+    sourceUrl: string;
+    url: string;
+    name: string;
+    contentType: string;
+    contentHash?: string;
+    contentSize?: number;
+} & Extra;
+export type ByteStream = ReadableStream<Uint8Array> | Uint8Array;
+interface Options {
+    computeVia?: () => unknown;
+    description?: string;
+    isUsed?: true;
+    configuration?: ConfigurationInput<any>;
+}
+interface RelationshipOptions extends Options {
+    query?: QueryWithInterpolations;
+}
+export interface CardContext<T extends CardDef = CardDef> {
+    commandContext?: CommandContext;
+    cardComponentModifier?: typeof Modifier<{
+        Args: {
+            Named: {
+                card?: CardDef;
+                cardId?: string;
+                format: Format | 'data';
+                fieldType: FieldType | undefined;
+                fieldName: string | undefined;
+            };
+        };
+    }>;
+    prerenderedCardSearchComponent: typeof GlimmerComponent<PrerenderedCardComponentSignature>;
+    getCard: getCard<T>;
+    getCards: getCards;
+    getCardCollection: getCardCollection;
+    store: Store;
+    mode?: 'host' | 'operator';
+    submode?: 'interact' | 'code' | 'host';
+}
+export interface FieldConstructor<T> {
+    cardThunk: () => T;
+    computeVia: undefined | (() => unknown);
+    declaredCardThunk?: () => T;
+    isUsed?: true;
+    isPolymorphic?: true;
+    name: string;
+    queryDefinition?: QueryWithInterpolations;
+}
+type CardChangeSubscriber = (instance: BaseDef, fieldName: string, fieldValue: any) => void;
+export declare function instanceOf(instance: BaseDef, clazz: typeof BaseDef): boolean;
+export declare function flushLogs(): Promise<void>;
+export interface StoreSearchResource<T extends CardDef | FileDef = CardDef> {
+    readonly instances: T[];
+    readonly instancesByRealm: {
+        realm: string;
+        cards: T[];
+    }[];
+    readonly isLoading: boolean;
+    readonly meta: QueryResultsMeta;
+    readonly errors?: ErrorEntry[];
+}
+export type GetSearchResourceFuncOpts = {
+    isLive?: boolean;
+    doWhileRefreshing?: (() => void) | undefined;
+    dependencyTracking?: RuntimeDependencyTrackingContext;
+    seed?: {
+        cards: CardDef[];
+        searchURL?: string;
+        realms?: string[];
+        queryErrors?: Array<{
+            realm: string;
+            type: string;
+            message: string;
+            status?: number;
+        }>;
+    };
+};
+export type GetSearchResourceFunc<T extends CardDef | FileDef = CardDef> = (parent: object, getQuery: () => Query | undefined, getRealms?: () => string[] | undefined, opts?: GetSearchResourceFuncOpts) => StoreSearchResource<T>;
+export interface CardStore {
+    getCard(url: string): CardDef | undefined;
+    getFileMeta(url: string): FileDef | undefined;
+    setCard(url: string, instance: CardDef): void;
+    setFileMeta(url: string, instance: FileDef): void;
+    setCardNonTracked(id: string, instance: CardDef): void;
+    setFileMetaNonTracked(id: string, instance: FileDef): void;
+    makeTracked(id: string): void;
+    loadCardDocument(url: string, opts?: {
+        dependencyTrackingContext?: RuntimeDependencyTrackingContext;
+    }): Promise<SingleCardDocument | CardError>;
+    loadFileMetaDocument(url: string, opts?: {
+        dependencyTrackingContext?: RuntimeDependencyTrackingContext;
+    }): Promise<SingleFileMetaDocument | CardError>;
+    trackLoad(load: Promise<unknown>): void;
+    loaded(): Promise<void>;
+    trackQueryLoad?(load: Promise<unknown>, meta: QueryLoadMeta): (() => void) | void;
+    queryLoadsInFlight?(): QueryLoadInfo[];
+    cardDocLoadsInFlight?(): Array<{
+        url: string;
+        ageMs: number;
+    }>;
+    fileMetaDocLoadsInFlight?(): Array<{
+        url: string;
+        ageMs: number;
+    }>;
+    recentCardDocLoads?(): Array<{
+        url: string;
+        ms: number;
+    }>;
+    recentFileMetaLoads?(): Array<{
+        url: string;
+        ms: number;
+    }>;
+    recentQueryLoads?(): Array<{
+        meta: QueryLoadMeta;
+        ms: number;
+    }>;
+    getSearchResource: GetSearchResourceFunc;
+}
+export interface QueryLoadMeta {
+    source: string;
+    query?: unknown;
+    realms?: string[];
+    cardId?: string;
+    fieldName?: string;
+}
+export interface QueryLoadInfo extends QueryLoadMeta {
+    ageMs: number;
+}
+export interface Field<CardT extends BaseDefConstructor = BaseDefConstructor, SearchT = any> {
+    card: CardT;
+    name: string;
+    fieldType: FieldType;
+    computeVia: undefined | (() => unknown);
+    configuration?: ConfigurationInput<any>;
+    queryDefinition?: QueryWithInterpolations;
+    captureQueryFieldSeedData?(instance: BaseDef, value: any, resource: LooseCardResource): void;
+    isUsed?: true;
+    isPolymorphic?: true;
+    serialize(value: any, doc: JSONAPISingleResourceDocument, visited: Set<string>, opts?: SerializeOpts): JSONAPIResource;
+    deserialize(value: any, doc: LooseSingleCardDocument | CardDocument, relationships: JSONAPIResource['relationships'] | undefined, fieldMeta: CardFields[string] | undefined, store: CardStore | undefined, instancePromise: Promise<BaseDef>, loadedValue: any, relativeTo: URL | undefined, opts?: DeserializeOpts): Promise<any>;
+    emptyValue(instance: BaseDef): any;
+    validate(instance: BaseDef, value: any): void;
+    component(model: Box<BaseDef>): BoxComponent;
+    getter(instance: BaseDef): BaseInstanceType<CardT> | undefined;
+    queryableValue(value: any, stack: BaseDef[]): SearchT;
+}
+export declare const field: PropertyDecorator;
+export declare function containsMany<FieldT extends FieldDefConstructor>(field: FieldT, options?: Options): BaseInstanceType<FieldT>[];
+export declare function contains<FieldT extends FieldDefConstructor>(field: FieldT, options?: Options): BaseInstanceType<FieldT>;
+export declare function linksTo<CardT extends LinkableDefConstructor>(cardOrThunk: CardT | (() => CardT), options?: RelationshipOptions): BaseInstanceType<CardT>;
+export declare function linksToMany<CardT extends LinkableDefConstructor>(cardOrThunk: CardT | (() => CardT), options?: RelationshipOptions): BaseInstanceType<CardT>[];
+export declare class BaseDef {
+    [isBaseInstance]: boolean;
+    [relativeTo]: URL | undefined;
+    [meta]: CardResourceMeta | undefined;
+    ['constructor']: BaseDefConstructor;
+    static baseDef: undefined;
+    static data?: Record<string, any>;
+    static displayName: any;
+    static icon: CardOrFieldTypeIcon;
+    static getDisplayName(instance: BaseDef): any;
+    static getIconComponent(instance: BaseDef): CardOrFieldTypeIcon;
+    get [realmURL](): URL | undefined;
+    static [emptyValue]: object | string | number | null | boolean | undefined;
+    static [serialize](value: any, doc: JSONAPISingleResourceDocument, visited?: Set<string>, opts?: SerializeOpts): any;
+    static [formatQuery](value: any): any;
+    static [queryableValue](value: any, stack?: BaseDef[]): any;
+    static [deserialize]<T extends BaseDefConstructor>(this: T, data: any, relativeTo: URL | undefined, doc?: CardDocument, store?: CardStore, opts?: DeserializeOpts): Promise<BaseInstanceType<T>>;
+    static getComponent(card: BaseDef, field?: Field, opts?: {
+        componentCodeRef?: CodeRef;
+    }): BoxComponent;
+    static assignInitialFieldValue(instance: BaseDef, fieldName: string, value: any): void;
+    constructor(data?: Record<string, any>);
+}
+export declare class Component<CardT extends BaseDefConstructor> extends GlimmerComponent<SignatureFor<CardT>> {
+}
+export type CreateCardFn = (ref: CodeRef, relativeTo: URL | undefined, opts?: {
+    realmURL?: URL;
+    localDir?: LocalPath;
+    doc?: LooseSingleCardDocument;
+    cardModeAfterCreation?: Format;
+}) => Promise<string | undefined>;
+export type ViewCardFn = (cardOrURL: CardDef | URL | RealmResourceIdentifier, format?: Format, opts?: {
+    type?: 'card' | 'file';
+    openCardInRightMostStack?: boolean;
+    stackIndex?: number;
+    fieldType?: 'linksTo' | 'contains' | 'containsMany' | 'linksToMany';
+    fieldName?: string;
+    useBaseTemplate?: boolean;
+}) => void;
+export type EditCardFn = (card: CardDef, opts?: {
+    useBaseTemplate?: boolean;
+}) => void;
+export type SaveCardFn = (id: RealmResourceIdentifier) => void;
+export type DeleteCardFn = (cardOrId: CardDef | URL | string) => Promise<void>;
+export interface CardCrudFunctions {
+    createCard: CreateCardFn;
+    saveCard: SaveCardFn;
+    editCard: EditCardFn;
+    viewCard: ViewCardFn;
+    deleteCard: DeleteCardFn;
+}
+export type BaseDefComponent = ComponentLike<{
+    Blocks: {};
+    Element: any;
+    Args: {
+        cardOrField: typeof BaseDef;
+        fields: any;
+        format: Format;
+        model: any;
+        set: Setter;
+        fieldName: string | undefined;
+        context?: CardContext;
+        canEdit?: boolean;
+        typeConstraint?: ResolvedCodeRef;
+        configuration?: FieldConfiguration | undefined;
+        createCard: CreateCardFn;
+        viewCard: ViewCardFn;
+        editCard: EditCardFn;
+        saveCard: SaveCardFn;
+    };
+}>;
+export declare class FieldDef extends BaseDef {
+    static isFieldDef: any;
+    static displayName: any;
+    static icon: any;
+    [realmContext]?: string;
+    get [realmURL](): URL | undefined;
+    static configuration?: ConfigurationInput<any>;
+    static embedded: BaseDefComponent;
+    static edit: BaseDefComponent;
+    static atom: BaseDefComponent;
+    static fitted: BaseDefComponent;
+    static markdown: BaseDefComponent;
+}
+export declare class ReadOnlyField extends FieldDef {
+    static [primitive]: string;
+    static [useIndexBasedKey]: never;
+    static embedded: any;
+    static edit: any;
+    static markdown: any;
+}
+export declare class StringField extends FieldDef {
+    static displayName: any;
+    static icon: any;
+    static [primitive]: string;
+    static [useIndexBasedKey]: never;
+    static embedded: any;
+    static edit: any;
+    static atom: any;
+    static markdown: BaseDefComponent;
+}
+export declare class MaybeBase64Field extends StringField {
+    static embedded: any;
+    static atom: any;
+    static markdown: any;
+}
+export declare class TextAreaField extends StringField {
+    static displayName: any;
+    static icon: any;
+    static edit: any;
+    static markdown: BaseDefComponent;
+}
+export declare class CSSField extends TextAreaField {
+    static displayName: any;
+    static embedded: any;
+    static markdown: any;
+}
+export declare class MarkdownField extends StringField {
+    static displayName: any;
+    static icon: any;
+    static embedded: any;
+    static atom: any;
+    static edit: any;
+    static markdown: any;
+}
+export declare function deserializeForUI(value: string | number | null): number | null;
+export declare function serializeForUI(val: number | null): string | undefined;
+export declare class NumberField extends FieldDef {
+    static displayName: any;
+    static icon: any;
+    static [primitive]: number;
+    static [fieldSerializer]: string;
+    static [useIndexBasedKey]: never;
+    static embedded: any;
+    static atom: any;
+    static edit: any;
+    static markdown: any;
+}
+export interface SerializedFileDef {
+    url?: string;
+    sourceUrl: string;
+    name?: string;
+    contentHash?: string;
+    contentSize?: number;
+    contentType?: string;
+    content?: string;
+    error?: string;
+}
+export declare class FileContentMismatchError extends Error {
+    name: string;
+}
+export declare class FileDef extends BaseDef {
+    static displayName: any;
+    static isFileDef: any;
+    static icon: any;
+    [isSavedInstance]: boolean;
+    get [realmURL](): URL | undefined;
+    static assignInitialFieldValue(instance: BaseDef, fieldName: string, value: any): void;
+    id: RealmResourceIdentifier;
+    sourceUrl: string;
+    url: string;
+    name: string;
+    contentType: string;
+    contentHash: string;
+    contentSize: number;
+    static embedded: BaseDefComponent;
+    static fitted: any;
+    static isolated: any;
+    static atom: any;
+    static edit: BaseDefComponent;
+    static markdown: BaseDefComponent;
+    static extractAttributes(url: string, getStream: () => Promise<ByteStream>, options?: {
+        contentHash?: string;
+        contentSize?: number;
+    }): Promise<SerializedFile>;
+    serialize(): {
+        sourceUrl: string;
+        url: string;
+        name: string;
+        contentType: string;
+        contentHash: string;
+        contentSize: number;
+    };
+    [getMenuItems](params: GetMenuItemParams): MenuItemOptions[];
+}
+export declare function createFileDef({ url, sourceUrl, name, contentType, contentHash, contentSize }: SerializedFileDef): FileDef;
+export { getDefaultFileMenuItems } from './file-menu-items';
+export declare class ImageDef extends FileDef {
+    static displayName: any;
+    static acceptTypes: any;
+    width: number;
+    height: number;
+    static isolated: BaseDefComponent;
+    static atom: BaseDefComponent;
+    static embedded: BaseDefComponent;
+    static fitted: BaseDefComponent;
+    static markdown: BaseDefComponent;
+}
+export declare class CardInfoField extends FieldDef {
+    static displayName: any;
+    name: string;
+    summary: string;
+    cardThumbnail: ImageDef;
+    cardThumbnailURL: string;
+    theme: Theme;
+    notes: string;
+}
+export declare class CardDef extends BaseDef {
+    readonly [localId]: string;
+    [isSavedInstance]: boolean;
+    get [fieldsUntracked](): Record<string, typeof BaseDef> | undefined;
+    get [fields](): Record<string, typeof BaseDef> | undefined;
+    set [fields](overrides: Record<string, typeof BaseDef>);
+    id: RealmResourceIdentifier;
+    cardInfo: CardInfoField;
+    cardTitle: string;
+    cardDescription: string;
+    cardTheme: InstanceType<typeof Theme> | null;
+    cardThumbnailURL: string;
+    static displayName: any;
+    static isCardDef: any;
+    static icon: any;
+    static assignInitialFieldValue(instance: BaseDef, fieldName: string, value: any): void;
+    static embedded: BaseDefComponent;
+    static fitted: BaseDefComponent;
+    static isolated: BaseDefComponent;
+    static edit: BaseDefComponent;
+    static atom: BaseDefComponent;
+    static head: BaseDefComponent;
+    static markdown: BaseDefComponent;
+    static get hasCustomEditTemplate(): boolean;
+    static get hasCustomIsolatedTemplate(): boolean;
+    static prefersWideFormat: any;
+    static headerColor: string | null;
+    constructor(data?: Record<string, any> & {
+        [fields]?: Record<string, BaseDefConstructor>;
+    });
+    get [realmInfo](): import("@cardstack/runtime-common").RealmInfo | undefined;
+    get [realmURL](): URL | undefined;
+    [getMenuItems](params: GetMenuItemParams): MenuItemOptions[];
+}
+export declare class CssImportField extends StringField {
+    static displayName: any;
+    static icon: any;
+}
+export declare class Theme extends CardDef {
+    static displayName: any;
+    static icon: any;
+    cssVariables: string;
+    cssImports: string[];
+    [getMenuItems](params: GetMenuItemParams): MenuItemOptions[];
+}
+export type BaseDefConstructor = typeof BaseDef;
+export type CardDefConstructor = typeof CardDef;
+export type FieldDefConstructor = typeof FieldDef;
+export type FileDefConstructor = typeof FileDef;
+export type LinkableDefConstructor = CardDefConstructor | FileDefConstructor;
+export declare function subscribeToChanges(fieldOrCard: BaseDef | BaseDef[], subscriber: CardChangeSubscriber, enclosing?: {
+    fieldOrCard: BaseDef;
+    fieldName: string;
+}): void;
+export declare function unsubscribeFromChanges(fieldOrCard: BaseDef | BaseDef[], subscriber: CardChangeSubscriber, visited?: Set<BaseDef>): void;
+export declare function setId(instance: CardDef, id: RealmResourceIdentifier): void;
+export declare function isSaved(instance: CardDef): boolean;
+export declare function getQueryableValue(field: Field<typeof BaseDef>, value: any, stack?: BaseDef[]): any;
+export declare function getQueryableValue(fieldCard: typeof BaseDef, value: any, stack?: BaseDef[]): any;
+export declare function formatQueryValue(field: Field<typeof BaseDef>, queryValue: any): any;
+export declare function createFromSerialized<T extends BaseDefConstructor>(resource: LooseLinkableResource<CardResource> | LooseLinkableResource<FileMetaResource>, doc: LooseSingleResourceDocument<CardResource | FileMetaResource> | LinkableDocument, relativeTo: URL | undefined, opts?: DeserializeOpts & {
+    store?: CardStore;
+    dependencyTrackingContext?: RuntimeDependencyTrackingContext;
+}): Promise<BaseInstanceType<T>>;
+export declare function updateFromSerialized<T extends BaseDefConstructor>(instance: BaseInstanceType<T>, doc: LooseSingleCardDocument, store?: CardStore, opts?: DeserializeOpts): Promise<BaseInstanceType<T>>;
+export declare function setCardAsSavedForTest(instance: CardDef, id?: string): void;
+export declare function searchDoc<CardT extends BaseDefConstructor>(instance: InstanceType<CardT>): Record<string, any>;
+export type SignatureFor<CardT extends BaseDefConstructor> = {
+    Args: {
+        model: PartialBaseInstanceType<CardT>;
+        fields: FieldsTypeFor<InstanceType<CardT>>;
+        set: Setter;
+        fieldName: string | undefined;
+        context?: CardContext;
+        createCard?: CreateCardFn;
+        viewCard?: ViewCardFn;
+        editCard?: EditCardFn;
+        saveCard?: SaveCardFn;
+        canEdit?: boolean;
+        configuration?: FieldConfiguration | undefined;
+    };
+};
+export declare function getComponent(model: BaseDef, field?: Field, opts?: {
+    componentCodeRef?: CodeRef;
+}): BoxComponent;
+export declare class Box<T> {
+    static create<T>(model: T): Box<T>;
+    private state;
+    private constructor();
+    get value(): T;
+    get name(): any;
+    set value(v: T);
+    set: <V extends T>(value: V) => void;
+    private fieldBoxes;
+    field<K extends keyof T>(fieldName: K, useIndexBasedKeys?: boolean): Box<T[K]>;
+    private prevChildren;
+    private prevValues;
+    get children(): Box<ElementType<T>>[];
+}
+type ElementType<T> = T extends (infer V)[] ? V : never;
+declare module 'ember-provide-consume-context/context-registry' {
+    export default interface ContextRegistry {
+        [CardContextName]: CardContext;
+    }
+}
+declare function getStore(instance: BaseDef): CardStore;

package/bundled-types/base/card-serialization.d.ts

@@ -0,0 +1,47 @@
+import type { CardDocument, CardResource, CardResourceMeta, FileMetaResource, LooseCardResource, LooseFileMetaResource, LooseSingleCardDocument, LooseSingleFileMetaDocument, Meta, RuntimeDependencyTrackingContext, SingleFileMetaDocument } from '@cardstack/runtime-common';
+import type { BaseDef, BaseDefConstructor, CardDef } from './card-api';
+import type { FileDef } from './file-api';
+import type { ResourceID } from '@cardstack/runtime-common';
+export type JSONAPIResource = {
+    attributes: Record<string, any>;
+    relationships?: Record<string, any>;
+    meta?: Record<string, any>;
+} | {
+    attributes?: Record<string, any>;
+    relationships: Record<string, any>;
+    meta?: Record<string, any>;
+};
+export interface JSONAPISingleResourceDocument {
+    data: Partial<JSONAPIResource> & {
+        type: string;
+    } & {
+        id?: string;
+    } & {
+        lid?: string;
+    };
+    included?: (Partial<JSONAPIResource> & ResourceID)[];
+}
+export interface SerializeOpts {
+    includeComputeds?: boolean;
+    includeUnrenderedFields?: boolean;
+    useAbsoluteURL?: boolean;
+    omitFields?: [typeof BaseDef];
+    omitQueryFields?: boolean;
+    maybeRelativeURL?: (possibleURL: string) => string;
+    overrides?: Map<string, typeof BaseDef>;
+}
+export interface DeserializeOpts {
+    ignoreBrokenLinks?: true;
+    dependencyTrackingContext?: RuntimeDependencyTrackingContext;
+}
+export declare const serialize: unique symbol;
+export declare const deserialize: unique symbol;
+export declare function cardClassFromResource<CardT extends BaseDefConstructor>(resource: LooseCardResource | CardResource | FileMetaResource | undefined, fallback: CardT, relativeTo: URL | undefined): Promise<CardT>;
+export declare function callSerializeHook(card: typeof BaseDef, value: any, doc: JSONAPISingleResourceDocument, visited?: Set<string>, opts?: any): any;
+export declare function getCardMeta<K extends keyof CardResourceMeta>(card: BaseDef, metaKey: K): CardResourceMeta[K] | undefined;
+export declare function makeMetaForField(meta: Partial<Meta> | undefined, fieldName: string, fallback: typeof BaseDef): Meta;
+export declare function makeRelativeURL(maybeURL: string, opts?: SerializeOpts): string;
+export declare function resourceFrom(doc: CardDocument | SingleFileMetaDocument | undefined, resourceId: string | undefined): CardResource | FileMetaResource | undefined;
+export declare function serializeCard(model: CardDef, opts?: SerializeOpts): LooseSingleCardDocument;
+export declare function serializeCardResource(model: CardDef | FileDef, doc: JSONAPISingleResourceDocument, opts?: SerializeOpts, visited?: Set<string>, resourceType?: string): LooseCardResource | LooseFileMetaResource;
+export declare function serializeFileDef(model: FileDef, opts?: SerializeOpts): LooseSingleFileMetaDocument;

package/bundled-types/base/cards-grid.d.ts

@@ -0,0 +1,10 @@
+import { CardDef, type BaseDef } from './card-api';
+export declare class CardsGrid extends CardDef {
+    static displayName: any;
+    static icon: any;
+    static isolated: any;
+    static prefersWideFormat: any;
+    realmName: string;
+    cardTitle: string;
+    static getDisplayName(instance: BaseDef): any;
+}

package/bundled-types/base/code-ref.d.ts

@@ -0,0 +1,14 @@
+import { primitive, FieldDef } from './card-api';
+import { type ResolvedCodeRef, fieldSerializer } from '@cardstack/runtime-common';
+export default class CodeRefField extends FieldDef {
+    static displayName: any;
+    static icon: any;
+    static [primitive]: ResolvedCodeRef;
+    static [fieldSerializer]: string;
+    static embedded: any;
+    static edit: any;
+    static markdown: any;
+}
+export declare class AbsoluteCodeRefField extends CodeRefField {
+    static [fieldSerializer]: string;
+}