@vitnode/core 0.0.1-canary.0

package/dist/src/content/types.d.ts

@@ -0,0 +1,764 @@
+import type { CONTENT_ADMIN_FORM_MODES, CONTENT_DELIVERY_DESCRIPTION_KINDS, CONTENT_DELIVERY_NO_INDEX_KINDS, CONTENT_DELIVERY_TITLE_KINDS, CONTENT_EDITORIAL_FIELDS, CONTENT_FILTERABLE_FIELD_KINDS, CONTENT_LOCALIZATION_FALLBACKS, CONTENT_PUBLIC_EXPOSABLE_COLUMNS, CONTENT_PUBLICATION_FIELDS, CONTENT_PUBLICATION_STATUSES, CONTENT_SEARCH_DESCRIPTION_KINDS, CONTENT_SEARCH_TEXT_KINDS, CONTENT_SEARCH_TITLE_KINDS, CONTENT_SITEMAP_CHANGE_FREQUENCIES, CONTENT_SYSTEM_FIELDS, CONTENT_TRANSLATION_SYSTEM_FIELDS } from "./const";
+import type { ContentFileDescriptor } from "./files";
+import type { ContentSchemas } from "./schemas";
+export type ContentSystemField = (typeof CONTENT_SYSTEM_FIELDS)[number];
+export type ContentPublicationField = (typeof CONTENT_PUBLICATION_FIELDS)[number];
+export type ContentEditorialField = (typeof CONTENT_EDITORIAL_FIELDS)[number];
+export type ContentTranslationSystemField = (typeof CONTENT_TRANSLATION_SYSTEM_FIELDS)[number];
+export type ContentPublicationStatus = (typeof CONTENT_PUBLICATION_STATUSES)[number];
+export type ContentOnDelete = "cascade" | "restrict" | "set null";
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export interface ContentFieldShared<TRequired extends boolean = boolean, TNullable extends boolean = boolean> {
+    description?: string;
+    localized?: boolean;
+    nullable: TNullable;
+    required: TRequired;
+}
+export interface ContentTextField<TRequired extends boolean = boolean, TNullable extends boolean = boolean, TDefault extends string | undefined = string | undefined, TLocalized extends boolean = boolean> extends ContentFieldShared<TRequired, TNullable> {
+    defaultValue: TDefault;
+    kind: "text";
+    localized: TLocalized;
+    maxLength?: number;
+    minLength?: number;
+    unique?: boolean;
+}
+export type ContentSlugRequired<TSource> = TSource extends string ? false : true;
+export interface ContentSlugField<TSource extends string | undefined = string | undefined, TLocalized extends boolean = boolean> extends ContentFieldShared<ContentSlugRequired<TSource>, false> {
+    kind: "slug";
+    localized: TLocalized;
+    maxLength?: number;
+    source: TSource;
+}
+export interface ContentTextareaField<TRequired extends boolean = boolean, TNullable extends boolean = boolean, TDefault extends string | undefined = string | undefined, TLocalized extends boolean = boolean> extends ContentFieldShared<TRequired, TNullable> {
+    defaultValue: TDefault;
+    kind: "textarea";
+    localized: TLocalized;
+    maxLength?: number;
+    minLength?: number;
+}
+export interface ContentNumberField<TRequired extends boolean = boolean, TNullable extends boolean = boolean, TDefault extends number | undefined = number | undefined> extends ContentFieldShared<TRequired, TNullable> {
+    defaultValue: TDefault;
+    integer: boolean;
+    kind: "number";
+    max?: number;
+    min?: number;
+}
+export interface ContentBooleanField<TRequired extends boolean = boolean, TNullable extends boolean = boolean, TDefault extends boolean | undefined = boolean | undefined> extends ContentFieldShared<TRequired, TNullable> {
+    defaultValue: TDefault;
+    kind: "boolean";
+}
+export interface ContentEnumField<TValues extends readonly [string, ...string[]] = readonly [
+    string,
+    ...string[]
+], TRequired extends boolean = boolean, TNullable extends boolean = boolean, TDefault extends TValues[number] | undefined = TValues[number] | undefined> extends ContentFieldShared<TRequired, TNullable> {
+    defaultValue: TDefault;
+    display?: "radio" | "select";
+    kind: "enum";
+    length?: number;
+    values: TValues;
+}
+export interface ContentFileField<TRequired extends boolean = boolean, TNullable extends boolean = boolean, TMultiple extends boolean = boolean, TOrdered extends boolean = boolean> extends ContentFieldShared<TRequired, TNullable> {
+    allowedExtensions?: string[];
+    allowedMimeTypes?: string[];
+    kind: "file";
+    max?: number;
+    maxBytes: number;
+    min?: number;
+    multiple: TMultiple;
+    ordered: TOrdered;
+}
+export interface ContentDateTimeField<TRequired extends boolean = boolean, TNullable extends boolean = boolean, TDefaultNow extends boolean = boolean> extends ContentFieldShared<TRequired, TNullable> {
+    defaultNow: TDefaultNow;
+    kind: "dateTime";
+}
+export interface ContentUserField<TRequired extends boolean = boolean, TNullable extends boolean = boolean, TMultiple extends boolean = boolean, TOrdered extends boolean = boolean> extends ContentFieldShared<TRequired, TNullable> {
+    kind: "user";
+    min?: number;
+    multiple: TMultiple;
+    onDelete: ContentOnDelete;
+    ordered: TOrdered;
+}
+interface ContentReferenceCollection {
+    kind: "file" | "relation" | "user";
+    multiple: true;
+}
+export interface ContentRelationField<TRequired extends boolean = boolean, TNullable extends boolean = boolean, TMultiple extends boolean = boolean, TOrdered extends boolean = boolean, TSelf extends boolean = boolean> extends ContentFieldShared<TRequired, TNullable> {
+    kind: "relation";
+    min?: number;
+    multiple: TMultiple;
+    onDelete: ContentOnDelete;
+    ordered: TOrdered;
+    self: TSelf;
+    target: () => AnyContentTypeDefinition;
+}
+export interface ContentGroupField<TFields = ContentLeafFieldMap, TRequired extends boolean = boolean, TNullable extends boolean = boolean, TLocalized extends boolean = boolean> extends ContentFieldShared<TRequired, TNullable> {
+    fields: TFields;
+    kind: "group";
+    localized: TLocalized;
+}
+export interface ContentRepeatableField<TFields = ContentLeafFieldMap> extends ContentFieldShared<false, false> {
+    fields: TFields;
+    kind: "repeatable";
+    max?: number;
+    min?: number;
+}
+export type ContentFieldDescriptor = ContentBooleanField | ContentDateTimeField | ContentEnumField | ContentFileField | ContentGroupField | ContentNumberField | ContentRelationField | ContentRepeatableField | ContentSlugField | ContentTextareaField | ContentTextField | ContentUserField;
+export type ContentFieldKind = ContentFieldDescriptor["kind"];
+export type ContentLeafFieldDescriptor = ContentBooleanField | ContentDateTimeField | ContentEnumField | ContentNumberField | ContentTextareaField | ContentTextField;
+export type ContentFieldMap = Record<string, ContentFieldDescriptor>;
+export type ContentLeafFieldMap = Record<string, ContentLeafFieldDescriptor>;
+export type ContentFieldsConstraint<TPublication extends boolean = false, TEditorial extends boolean = false> = Partial<Record<ContentSystemField, never>> & Record<string, {
+    kind: ContentFieldKind;
+}> & (TEditorial extends true ? Partial<Record<ContentEditorialField, never>> : unknown) & (TPublication extends true ? Partial<Record<ContentPublicationField, never>> : unknown);
+export type ContentReferenceField = ContentRelationField | ContentUserField;
+type ApplyNullable<TValue, TField> = TField extends {
+    nullable: true;
+} ? null | TValue : TValue;
+type ScalarFieldValue<TField> = TField extends {
+    kind: "boolean";
+} ? boolean : TField extends {
+    kind: "dateTime";
+} ? Date : TField extends {
+    values: readonly (infer TValue)[];
+} ? TValue : TField extends {
+    kind: "file" | "number" | "relation" | "user";
+} ? number : string;
+type ScalarFieldInput<TField> = TField extends {
+    kind: "boolean";
+} ? boolean : TField extends {
+    kind: "dateTime";
+} ? string : TField extends {
+    values: readonly (infer TValue)[];
+} ? TValue : TField extends {
+    kind: "file" | "number" | "relation" | "user";
+} ? number : string;
+type ContentGroupValue<TFields> = Prettify<{
+    [K in keyof TFields]: ContentFieldValue<TFields[K]>;
+}>;
+export type ContentRepeatableRow<TFields> = Prettify<{
+    [K in keyof TFields]: ContentFieldValue<TFields[K]>;
+} & {
+    id: number;
+}>;
+export type ContentValuesOf<TFields> = CreateValuesOf<TFields, keyof TFields>;
+export type ContentInnerFieldsOf<TDefinition, TName> = ContentFieldsOf<TDefinition>[keyof ContentFieldsOf<TDefinition> & TName] extends {
+    fields: infer TInner;
+} ? TInner : never;
+export type ContentRepeatableInputRow<TFields> = Prettify<CreateValuesOf<TFields, keyof TFields> & {
+    id?: number;
+}>;
+export type ContentFieldValue<TField> = TField extends {
+    fields: infer TInner;
+    kind: "group";
+} ? ApplyNullable<ContentGroupValue<TInner>, TField> : TField extends {
+    fields: infer TInner;
+    kind: "repeatable";
+} ? ContentRepeatableRow<TInner>[] : TField extends ContentReferenceCollection ? number[] : ApplyNullable<ScalarFieldValue<TField>, TField>;
+export type ContentFieldInput<TField> = TField extends {
+    fields: infer TInner;
+    kind: "group";
+} ? ApplyNullable<CreateValuesOf<TInner, keyof TInner>, TField> : TField extends {
+    fields: infer TInner;
+    kind: "repeatable";
+} ? ContentRepeatableInputRow<TInner>[] : TField extends ContentReferenceCollection ? number[] : ApplyNullable<ScalarFieldInput<TField>, TField>;
+export type ContentFieldPatch<TField> = TField extends {
+    fields: infer TInner;
+    kind: "group";
+} ? ApplyNullable<Prettify<Partial<CreateValuesOf<TInner, keyof TInner>>>, TField> : ContentFieldInput<TField>;
+export type HasColumnDefault<TField> = TField extends {
+    kind: "dateTime";
+} ? TField extends {
+    defaultNow: true;
+} ? true : false : TField extends {
+    defaultValue: infer TDefault;
+} ? [TDefault] extends [undefined] ? false : true : false;
+type RequiredFieldKeys<TFields> = {
+    [K in keyof TFields]: TFields[K] extends {
+        required: true;
+    } ? K : never;
+}[keyof TFields];
+type LocalizedFieldKeys<TFields> = {
+    [K in keyof TFields]: TFields[K] extends {
+        localized: true;
+    } ? K : never;
+}[keyof TFields];
+type SharedFieldKeys<TFields> = Exclude<keyof TFields, LocalizedFieldKeys<TFields>>;
+type CollectionFieldKeys<TFields> = {
+    [K in keyof TFields]: TFields[K] extends {
+        kind: "repeatable";
+    } ? K : TFields[K] extends ContentReferenceCollection ? K : never;
+}[keyof TFields];
+type ColumnFieldKeys<TFields> = Exclude<SharedFieldKeys<TFields>, CollectionFieldKeys<TFields>>;
+type GroupFieldKeys<TFields> = {
+    [K in keyof TFields]: TFields[K] extends {
+        kind: "group";
+    } ? K : never;
+}[keyof TFields];
+type ScalarColumnFieldKeys<TFields> = Exclude<ColumnFieldKeys<TFields>, GroupFieldKeys<TFields>>;
+type ScalarDisplayFieldKeys<TFields> = Exclude<Exclude<keyof TFields, CollectionFieldKeys<TFields>>, GroupFieldKeys<TFields>>;
+export type ContentLeafPath<TFields> = string & {
+    [K in GroupFieldKeys<TFields>]: TFields[K] extends {
+        fields: infer TInner;
+    } ? `${K & string}.${keyof TInner & string}` : never;
+}[GroupFieldKeys<TFields>];
+export type ContentRepeatableLeafPath<TFields> = string & {
+    [K in keyof TFields]: TFields[K] extends {
+        fields: infer TInner;
+        kind: "repeatable";
+    } ? `${K & string}.${keyof TInner & string}` : never;
+}[keyof TFields];
+export type ContentChangedPath<TDefinition> = (CollectionFieldKeys<ContentFieldsOf<TDefinition>> & string) | ContentLeafPath<ContentFieldsOf<TDefinition>> | (ScalarColumnFieldKeys<ContentFieldsOf<TDefinition>> & string);
+export type ContentRelationCollectionName<TDefinition> = string & {
+    [K in keyof ContentFieldsOf<TDefinition>]: ContentFieldsOf<TDefinition>[K] extends ContentReferenceCollection ? K : never;
+}[keyof ContentFieldsOf<TDefinition>];
+export type ContentRepeatableFieldName<TDefinition> = string & {
+    [K in keyof ContentFieldsOf<TDefinition>]: ContentFieldsOf<TDefinition>[K] extends {
+        kind: "repeatable";
+    } ? K : never;
+}[keyof ContentFieldsOf<TDefinition>];
+export type ContentAdvancedValues<TDefinition> = Prettify<{
+    [K in ContentRelationCollectionName<TDefinition> | ContentRepeatableFieldName<TDefinition>]: ContentFieldValue<ContentFieldsOf<TDefinition>[K]>;
+}>;
+type CreateValuesOf<TFields, TKeys extends keyof TFields> = Prettify<{
+    [K in Exclude<TKeys, RequiredFieldKeys<TFields>>]?: ContentFieldInput<TFields[K]>;
+} & {
+    [K in Extract<TKeys, RequiredFieldKeys<TFields>>]: ContentFieldInput<TFields[K]>;
+}>;
+type ContentPublicationColumn<TPublication extends boolean> = TPublication extends true ? ContentPublicationField : never;
+type ContentEditorialColumn<TEditorial extends boolean> = TEditorial extends true ? ContentEditorialField : never;
+type ContentAddressableColumn<TFields, TPublication extends boolean, TEditorial extends boolean> = ContentEditorialColumn<TEditorial> | ContentPublicationColumn<TPublication> | ContentSystemField | ScalarColumnFieldKeys<TFields>;
+type ContentDisplayColumn<TFields, TPublication extends boolean, TEditorial extends boolean> = ContentEditorialColumn<TEditorial> | ContentPublicationColumn<TPublication> | ContentSystemField | ScalarDisplayFieldKeys<TFields>;
+export interface ContentAdminListConfig<TFields = ContentFieldMap, TPublication extends boolean = boolean, TEditorial extends boolean = boolean> {
+    columns?: ContentDisplayColumn<TFields, TPublication, TEditorial>[];
+    defaultOrder?: "asc" | "desc";
+    defaultOrderBy?: ContentAddressableColumn<TFields, TPublication, TEditorial>;
+    orderableFields?: ScalarColumnFieldKeys<TFields>[];
+    searchableFields?: ScalarColumnFieldKeys<TFields>[];
+}
+export type ContentAdminFormMode = (typeof CONTENT_ADMIN_FORM_MODES)[number];
+export interface ContentAdminActionConfig {
+    mode?: ContentAdminFormMode;
+}
+export interface ContentAdminFormSection<TFields = ContentFieldMap> {
+    fields: (keyof TFields)[];
+    name: string;
+}
+export interface ContentAdminConfig<TFields = ContentFieldMap, TPublication extends boolean = boolean, TEditorial extends boolean = boolean> {
+    colorField?: null | string;
+    create?: ContentAdminActionConfig;
+    edit?: ContentAdminActionConfig;
+    form?: {
+        fields?: (keyof TFields)[];
+        sections?: ContentAdminFormSection<TFields>[];
+    };
+    list?: ContentAdminListConfig<TFields, TPublication, TEditorial>;
+    navigation?: {
+        enabled?: boolean;
+    };
+    path?: string;
+    permissionModule?: string;
+    titleField?: null | ScalarDisplayFieldKeys<TFields>;
+}
+export interface ResolvedContentAdminConfig {
+    colorField: null | string;
+    create: {
+        mode: ContentAdminFormMode;
+    };
+    edit: {
+        mode: ContentAdminFormMode;
+    };
+    form: {
+        fields: string[];
+        sections: {
+            fields: string[];
+            name: string;
+        }[];
+    };
+    list: {
+        columns: string[];
+        defaultOrder: "asc" | "desc";
+        defaultOrderBy: string;
+        orderableFields: string[];
+        searchableFields: string[];
+    };
+    navigation: {
+        enabled: boolean;
+    };
+    path: string;
+    titleField: null | string;
+}
+export interface ContentIndexInput<TFields = ContentFieldMap, TPublication extends boolean = boolean, TEditorial extends boolean = boolean> {
+    name?: string;
+    on: [
+        ContentIndexColumn<TFields, TPublication, TEditorial>,
+        ...ContentIndexColumn<TFields, TPublication, TEditorial>[]
+    ];
+    unique?: boolean;
+}
+type ContentIndexColumn<TFields, TPublication extends boolean, TEditorial extends boolean> = (ContentAddressableColumn<TFields, TPublication, TEditorial> | ContentLeafPath<TFields>) & string;
+export interface ContentIndexConfig {
+    name?: string;
+    on: string[];
+    unique?: boolean;
+}
+export interface ResolvedContentIndex {
+    name: string;
+    on: string[];
+    unique: boolean;
+}
+export interface ContentPublicationConfig {
+    enabled: true;
+}
+export interface ResolvedContentPublicationConfig<TEnabled extends boolean = boolean> {
+    enabled: TEnabled;
+}
+type ContentPublicationColumns<TDefinition> = TDefinition extends {
+    publication: {
+        enabled: true;
+    };
+} ? {
+    publishedAt: Date | null;
+    status: ContentPublicationStatus;
+} : Record<never, never>;
+export type ContentPublicExposableField<TFields> = (typeof CONTENT_PUBLIC_EXPOSABLE_COLUMNS)[number] | ContentLeafPath<TFields> | ContentRepeatableLeafPath<TFields> | (ExposableFlatFieldKeys<TFields> & string);
+type ExposableFlatFieldKeys<TFields> = Exclude<keyof TFields, GroupFieldKeys<TFields> | {
+    [K in keyof TFields]: TFields[K] extends {
+        kind: "repeatable";
+    } ? K : never;
+}[keyof TFields]>;
+export interface ContentPublicApiConfig<TField extends string = string> {
+    defaultOrder?: "asc" | "desc";
+    defaultOrderBy?: "publishedAt" | TField;
+    enabled: true;
+    fields: readonly [TField, ...TField[]];
+    filterableFields?: readonly TField[];
+    orderableFields?: readonly TField[];
+    path: string;
+    searchableFields?: readonly TField[];
+}
+export interface ResolvedContentPublicApiConfig<TField extends string = string, TEnabled extends boolean = boolean> {
+    defaultOrder: "asc" | "desc";
+    defaultOrderBy: string;
+    enabled: TEnabled;
+    fields: TField[];
+    filterableFields: string[];
+    orderableFields: string[];
+    path: string;
+    searchableFields: string[];
+    slugField: string;
+}
+type ContentFieldNamesOfKind<TFields, TKind extends string> = string & {
+    [K in keyof TFields]: TFields[K] extends {
+        kind: TKind;
+    } ? K : never;
+}[keyof TFields];
+type ContentLeafPathsOfKind<TFields, TKind extends string, TContainer extends string> = string & {
+    [K in keyof TFields]: TFields[K] extends {
+        fields: infer TInner;
+        kind: TContainer;
+    } ? {
+        [L in keyof TInner]: TInner[L] extends {
+            kind: TKind;
+        } ? `${K & string}.${L & string}` : never;
+    }[keyof TInner] : never;
+}[keyof TFields];
+type ContentNonNullableFieldNamesOfKind<TFields, TKind extends string> = string & {
+    [K in keyof TFields]: TFields[K] extends {
+        kind: TKind;
+        nullable: false;
+    } ? K : never;
+}[keyof TFields];
+export type ContentSearchTitleField<TFields, TPublicField extends string> = Extract<TPublicField, ContentNonNullableFieldNamesOfKind<TFields, (typeof CONTENT_SEARCH_TITLE_KINDS)[number]>>;
+export interface ContentRelationJunction {
+    field: string;
+    positionIndexName: string;
+    primaryKeyName: string;
+    relatedIndexName: string;
+    tableName: string;
+}
+export interface ContentRepeatableTable {
+    field: string;
+    positionIndexName: string;
+    tableName: string;
+}
+export type ContentSearchDescriptionField<TFields, TPublicField extends string> = Extract<TPublicField, ContentFieldNamesOfKind<TFields, (typeof CONTENT_SEARCH_DESCRIPTION_KINDS)[number]> | ContentLeafPathsOfKind<TFields, (typeof CONTENT_SEARCH_DESCRIPTION_KINDS)[number], "group">>;
+export type ContentSearchTextField<TFields, TPublicField extends string> = Extract<TPublicField, ContentFieldNamesOfKind<TFields, (typeof CONTENT_SEARCH_TEXT_KINDS)[number]> | ContentLeafPathsOfKind<TFields, (typeof CONTENT_SEARCH_TEXT_KINDS)[number], "group"> | ContentLeafPathsOfKind<TFields, (typeof CONTENT_SEARCH_TEXT_KINDS)[number], "repeatable">>;
+export interface ContentSearchConfig<TTitle extends string = string, TDescription extends string = string, TText extends string = string> {
+    contentFields: readonly [TText, ...TText[]];
+    descriptionField?: TDescription;
+    enabled: true;
+    pathTemplate: string;
+    titleField: TTitle;
+}
+export type ContentSearchEnabled<TSearch> = TSearch extends {
+    enabled: true;
+} ? true : false;
+export interface ResolvedContentSearchConfig<TEnabled extends boolean = boolean> {
+    contentFields: string[];
+    descriptionField: null | string;
+    enabled: TEnabled;
+    pathTemplate: string;
+    titleField: string;
+}
+export type ContentSitemapChangeFrequency = (typeof CONTENT_SITEMAP_CHANGE_FREQUENCIES)[number];
+export type ContentDeliveryTextField<TFields, TPublicField extends string, TKind extends string> = Extract<TPublicField, ContentFieldNamesOfKind<TFields, TKind> | ContentLeafPathsOfKind<TFields, TKind, "group">>;
+export type ContentDeliveryTitleField<TFields, TPublicField extends string> = ContentDeliveryTextField<TFields, TPublicField, (typeof CONTENT_DELIVERY_TITLE_KINDS)[number]>;
+export type ContentDeliveryDescriptionField<TFields, TPublicField extends string> = ContentDeliveryTextField<TFields, TPublicField, (typeof CONTENT_DELIVERY_DESCRIPTION_KINDS)[number]>;
+export type ContentDeliveryNoIndexField<TFields, TPublicField extends string> = ContentDeliveryTextField<TFields, TPublicField, (typeof CONTENT_DELIVERY_NO_INDEX_KINDS)[number]>;
+export interface ContentDeliveryOpenGraphConfig<TTitle extends string = string, TDescription extends string = string> {
+    descriptionField?: TDescription;
+    titleField?: TTitle;
+}
+export interface ContentDeliverySeoConfig<TTitle extends string = string, TDescription extends string = string, TNoIndex extends string = string> {
+    descriptionField?: TDescription;
+    fallbackDescriptionField?: TDescription;
+    fallbackTitleField?: TTitle;
+    noIndexField?: TNoIndex;
+    openGraph?: ContentDeliveryOpenGraphConfig<TTitle, TDescription>;
+    titleField?: TTitle;
+}
+export interface ContentDeliveryRedirectsConfig {
+    enabled: true;
+}
+export interface ContentDeliverySitemapConfig {
+    changeFrequency?: ContentSitemapChangeFrequency;
+    enabled: true;
+    priority?: number;
+}
+export interface ContentDeliveryHreflangConfig {
+    xDefault: "defaultLocale";
+}
+export interface ContentDeliveryConfig<TPublicEnabled extends boolean = true, TEditorialEnabled extends boolean = true, TTitle extends string = string, TDescription extends string = string, TNoIndex extends string = string> {
+    enabled: TPublicEnabled extends true ? true : never;
+    hreflang?: ContentDeliveryHreflangConfig;
+    redirects?: TPublicEnabled extends true ? TEditorialEnabled extends true ? ContentDeliveryRedirectsConfig | {
+        enabled: false;
+    } : {
+        enabled: false;
+    } : {
+        enabled: false;
+    };
+    seo?: ContentDeliverySeoConfig<TTitle, TDescription, TNoIndex>;
+    sitemap?: ContentDeliverySitemapConfig | {
+        enabled: false;
+    };
+}
+export type ContentDeliveryEnabled<TDelivery> = TDelivery extends {
+    enabled: true;
+} ? true : false;
+export interface ResolvedContentDeliverySeoConfig {
+    descriptionField: null | string;
+    fallbackDescriptionField: null | string;
+    fallbackTitleField: null | string;
+    noIndexField: null | string;
+    openGraph: null | {
+        descriptionField: null | string;
+        titleField: null | string;
+    };
+    titleField: null | string;
+}
+export interface ResolvedContentDeliveryConfig<TEnabled extends boolean = boolean> {
+    enabled: TEnabled;
+    hreflang: {
+        xDefault: "defaultLocale" | null;
+    };
+    redirects: {
+        enabled: boolean;
+    };
+    seo: ResolvedContentDeliverySeoConfig;
+    sitemap: {
+        changeFrequency: ContentSitemapChangeFrequency | null;
+        enabled: boolean;
+        priority: null | number;
+    };
+    slugScope: "localized" | "none" | "shared";
+}
+export interface ContentEditorialRevisionsConfig {
+    retention?: number;
+}
+export interface ContentEditorialPreviewConfig {
+    enabled: true;
+    expiresInMinutes?: number;
+    pathTemplate?: string;
+}
+export interface ContentEditorialSchedulingConfig {
+    enabled: true;
+}
+export interface ContentEditorialConfig<TPublicEnabled extends boolean = boolean, TPublication extends boolean = boolean> {
+    enabled: true;
+    preview?: TPublicEnabled extends true ? ContentEditorialPreviewConfig | {
+        enabled: false;
+    } : {
+        enabled: false;
+    };
+    revisions?: ContentEditorialRevisionsConfig;
+    scheduling?: TPublication extends true ? ContentEditorialSchedulingConfig | {
+        enabled: false;
+    } : {
+        enabled: false;
+    };
+}
+export type ContentEditorialEnabled<TEditorial> = TEditorial extends {
+    enabled: true;
+} ? true : false;
+export type ContentPreviewEnabled<TEditorial> = TEditorial extends {
+    enabled: true;
+    preview: {
+        enabled: true;
+    };
+} ? true : false;
+export type ContentSchedulingEnabled<TEditorial> = TEditorial extends {
+    enabled: true;
+    scheduling: {
+        enabled: true;
+    };
+} ? true : false;
+export interface ResolvedContentEditorialConfig<TEnabled extends boolean = boolean, TPreview extends boolean = boolean, TScheduling extends boolean = boolean> {
+    enabled: TEnabled;
+    preview: {
+        enabled: TPreview;
+        expiresInMinutes: number;
+        pathTemplate: null | string;
+    };
+    revisions: {
+        retention: number;
+    };
+    scheduling: {
+        enabled: TScheduling;
+    };
+}
+type ContentEditorialColumns<TDefinition> = TDefinition extends {
+    editorial: {
+        enabled: true;
+    };
+} ? {
+    version: number;
+} : Record<never, never>;
+export type ContentLocalizationFallback = (typeof CONTENT_LOCALIZATION_FALLBACKS)[number];
+export interface ContentLocalizationConfig {
+    defaultLocale: string;
+    enabled: true;
+    fallback?: ContentLocalizationFallback;
+}
+export interface ResolvedContentLocalizationConfig<TEnabled extends boolean = boolean> {
+    defaultLocale: string;
+    enabled: TEnabled;
+    fallback: ContentLocalizationFallback;
+    translationIndexes: ResolvedContentIndex[];
+    translationTableName: string;
+}
+export type ContentLocalizationEnabled<TLocalization> = TLocalization extends {
+    enabled: true;
+} ? true : false;
+export type ContentLocalizedFieldName<TDefinition> = LocalizedFieldKeys<ContentFieldsOf<TDefinition>> & string;
+export type ContentSharedFieldName<TDefinition> = SharedFieldKeys<ContentFieldsOf<TDefinition>> & string;
+export type ContentLocalizedValues<TDefinition> = CreateValuesOf<ContentFieldsOf<TDefinition>, keyof ContentFieldsOf<TDefinition> & LocalizedFieldKeys<ContentFieldsOf<TDefinition>>>;
+export type ContentSharedValues<TDefinition> = CreateValuesOf<ContentFieldsOf<TDefinition>, keyof ContentFieldsOf<TDefinition> & SharedFieldKeys<ContentFieldsOf<TDefinition>>>;
+export type ContentLocalizedUpdateValues<TDefinition> = Prettify<Partial<ContentLocalizedValues<TDefinition>>>;
+export type ContentTranslationPublicationColumns<TDefinition> = TDefinition extends {
+    publication: {
+        enabled: true;
+    };
+} ? {
+    publishedAt: Date | null;
+    status: ContentPublicationStatus;
+} : Record<never, never>;
+export type ContentTranslationRow<TDefinition> = Prettify<ContentTranslationPublicationColumns<TDefinition> & {
+    createdAt: Date;
+    itemId: number;
+    languageId: number;
+    locale: string;
+    updatedAt: Date;
+    values: ContentLocalizedValues<TDefinition>;
+    version: number;
+}>;
+export type ContentTranslationMeta<TDefinition = AnyContentTypeDefinition> = Prettify<ContentTranslationPublicationColumns<TDefinition> & {
+    createdAt: Date;
+    itemId: number;
+    languageId: number;
+    locale: string;
+    updatedAt: Date;
+    version: number;
+}>;
+export type SearchableContentTypeDefinition = AnyContentTypeDefinition & {
+    search: {
+        enabled: true;
+    };
+};
+export type PublicContentTypeDefinition = AnyContentTypeDefinition & {
+    publicApi: {
+        enabled: true;
+    };
+};
+export type EditorialContentTypeDefinition = AnyContentTypeDefinition & {
+    editorial: {
+        enabled: true;
+    };
+};
+export type PreviewableContentTypeDefinition = EditorialContentTypeDefinition & PublicContentTypeDefinition & {
+    editorial: {
+        preview: {
+            enabled: true;
+        };
+    };
+};
+export type SchedulableContentTypeDefinition = EditorialContentTypeDefinition & {
+    editorial: {
+        scheduling: {
+            enabled: true;
+        };
+    };
+    publication: {
+        enabled: true;
+    };
+};
+export type DeliverableContentTypeDefinition = PublicContentTypeDefinition & {
+    delivery: {
+        enabled: true;
+    };
+};
+export type LocalizedContentTypeDefinition = AnyContentTypeDefinition & {
+    localization: {
+        enabled: true;
+    };
+};
+export interface ResolvedContentAdvancedConfig {
+    junctions: ContentRelationJunction[];
+    leaves: ContentLeafColumn[];
+    repeatables: ContentRepeatableTable[];
+}
+export interface ContentLeafColumn {
+    columnName: string;
+    group: string;
+    leaf: string;
+    localized: boolean;
+    path: string;
+}
+export interface ContentTypeDefinition<TId extends string = string, TFields = ContentFieldMap, TPublication extends boolean = boolean, TPublicField extends string = string, TPublicEnabled extends boolean = boolean, TSearchEnabled extends boolean = boolean, TEditorialEnabled extends boolean = boolean, TPreviewEnabled extends boolean = boolean, TSchedulingEnabled extends boolean = boolean, TLocalizationEnabled extends boolean = boolean, TDeliveryEnabled extends boolean = boolean> {
+    admin: ResolvedContentAdminConfig;
+    advanced: ResolvedContentAdvancedConfig;
+    delivery: ResolvedContentDeliveryConfig<TDeliveryEnabled>;
+    editorial: ResolvedContentEditorialConfig<TEditorialEnabled, TPreviewEnabled, TSchedulingEnabled>;
+    fields: TFields;
+    id: TId;
+    indexes: ResolvedContentIndex[];
+    localization: ResolvedContentLocalizationConfig<TLocalizationEnabled>;
+    permissionModule: string;
+    publicApi: ResolvedContentPublicApiConfig<TPublicField, TPublicEnabled>;
+    publication: ResolvedContentPublicationConfig<TPublication>;
+    schemas: ContentSchemas<ContentTypeDefinition<TId, TFields, TPublication, TPublicField, TPublicEnabled, TSearchEnabled, TEditorialEnabled, TPreviewEnabled, TSchedulingEnabled, TLocalizationEnabled, TDeliveryEnabled>>;
+    search: ResolvedContentSearchConfig<TSearchEnabled>;
+    tableName: string;
+}
+export type AnyContentTypeDefinition = ContentTypeDefinition;
+export type ContentFieldsOf<TDefinition> = TDefinition extends {
+    fields: infer TFields;
+} ? TFields : never;
+export type ContentSelect<TDefinition> = Prettify<ContentEditorialColumns<TDefinition> & ContentPublicationColumns<TDefinition> & {
+    [K in ColumnFieldKeys<ContentFieldsOf<TDefinition>>]: ContentFieldValue<ContentFieldsOf<TDefinition>[K]>;
+} & {
+    createdAt: Date;
+    id: number;
+    updatedAt: Date;
+}>;
+export type ContentDetail<TDefinition> = Prettify<ContentAdvancedValues<TDefinition> & ContentSelect<TDefinition>>;
+export type ContentCreateInput<TDefinition> = ContentSharedValues<TDefinition>;
+export type ContentUpdateInput<TDefinition> = Prettify<{
+    [K in SharedFieldKeys<ContentFieldsOf<TDefinition>>]?: ContentFieldPatch<ContentFieldsOf<TDefinition>[K]>;
+}>;
+export type ContentFieldName<TDefinition> = keyof ContentFieldsOf<TDefinition> & string;
+type FieldNamesOfKind<TDefinition, TKind extends ContentFieldKind> = string & {
+    [K in ScalarColumnFieldKeys<ContentFieldsOf<TDefinition>>]: ContentFieldsOf<TDefinition>[K] extends {
+        kind: TKind;
+    } ? K : never;
+}[ScalarColumnFieldKeys<ContentFieldsOf<TDefinition>>];
+export type FilterableContentFieldKind = (typeof CONTENT_FILTERABLE_FIELD_KINDS)[number];
+export type FilterableContentFieldName<TDefinition> = FieldNamesOfKind<TDefinition, FilterableContentFieldKind>;
+type AnyFieldNamesOfKind<TDefinition, TKind extends ContentFieldKind> = Exclude<{
+    [K in keyof ContentFieldsOf<TDefinition>]: ContentFieldsOf<TDefinition>[K] extends {
+        kind: TKind;
+    } ? K : never;
+}[keyof ContentFieldsOf<TDefinition>], CollectionFieldKeys<ContentFieldsOf<TDefinition>>> & string;
+export type PublicFilterableContentFieldName<TDefinition> = AnyFieldNamesOfKind<TDefinition, FilterableContentFieldKind>;
+export interface ContentRelationFilter {
+    contains: number;
+}
+export type ContentFilterInput<TDefinition> = Partial<Record<ContentRelationCollectionName<TDefinition>, ContentRelationFilter> & (TDefinition extends {
+    publication: {
+        enabled: true;
+    };
+} ? {
+    status: ContentPublicationStatus;
+} : Record<never, never>) & {
+    [K in FilterableContentFieldName<TDefinition>]: ContentFieldInput<ContentFieldsOf<TDefinition>[K]>;
+}>;
+export type ContentOrderableFieldName<TDefinition> = ContentSharedFieldName<TDefinition> | ContentSystemField | (TDefinition extends {
+    editorial: {
+        enabled: true;
+    };
+} ? ContentEditorialField : never) | (TDefinition extends {
+    publication: {
+        enabled: true;
+    };
+} ? ContentPublicationField : never);
+export type ContentReferenceFieldName<TDefinition> = FieldNamesOfKind<TDefinition, "relation" | "user">;
+export interface ContentPublicRelation {
+    id: number;
+}
+export type ContentPublicFieldName<TDefinition> = TDefinition extends {
+    publicApi: {
+        fields: (infer TField extends string)[];
+    };
+} ? TField : never;
+type ContentPublicValue<TFields, TName extends string> = TName extends "id" ? number : TName extends "createdAt" | "updatedAt" ? Date : TName extends "publishedAt" ? Date | null : TName extends keyof TFields ? TFields[TName] extends {
+    kind: "file";
+    multiple: true;
+} ? ContentFileDescriptor[] : TFields[TName] extends {
+    kind: "file";
+} ? TFields[TName] extends {
+    nullable: true;
+} ? ContentFileDescriptor | null : ContentFileDescriptor : TFields[TName] extends {
+    kind: "relation";
+    multiple: true;
+} ? number[] : TFields[TName] extends {
+    kind: "relation";
+} ? TFields[TName] extends {
+    nullable: true;
+} ? ContentPublicRelation | null : ContentPublicRelation : ContentFieldValue<TFields[TName]> : never;
+type PublicPathOwner<TName> = TName extends `${infer TOwner}.${string}` ? TOwner : never;
+type PublicPathLeaf<TName, TOwner extends string> = TName extends `${TOwner}.${infer TLeaf}` ? TLeaf : never;
+type PublicFlatName<TName> = TName extends `${string}.${string}` ? never : TName;
+type ContentPublicNested<TFields, TName extends string> = {
+    [TOwner in keyof TFields & PublicPathOwner<TName>]: TFields[TOwner] extends {
+        fields: infer TInner;
+        kind: "repeatable";
+    } ? Prettify<{
+        [TLeaf in keyof TInner & PublicPathLeaf<TName, string & TOwner>]: ContentFieldValue<TInner[TLeaf]>;
+    } & {
+        id: number;
+    }>[] : TFields[TOwner] extends {
+        fields: infer TInner;
+        kind: "group";
+    } ? ApplyNullable<Prettify<{
+        [TLeaf in keyof TInner & PublicPathLeaf<TName, string & TOwner>]: ContentFieldValue<TInner[TLeaf]>;
+    }>, TFields[TOwner]> : never;
+};
+export type ContentPublicSelect<TDefinition> = Prettify<ContentPublicLocaleColumn<TDefinition> & ContentPublicNested<ContentFieldsOf<TDefinition>, ContentPublicFieldName<TDefinition>> & {
+    [K in PublicFlatName<ContentPublicFieldName<TDefinition>>]: ContentPublicValue<ContentFieldsOf<TDefinition>, K>;
+}>;
+type ContentPublicLocaleColumn<TDefinition> = TDefinition extends {
+    localization: {
+        enabled: true;
+    };
+} ? {
+    locale: string;
+} : Record<never, never>;
+export type ContentPublicListRow<TDefinition> = ContentPublicSelect<TDefinition>;
+export type ContentPublicFilterInput<TDefinition> = Partial<Record<ContentPublicFieldName<TDefinition> & ContentRelationCollectionName<TDefinition>, ContentRelationFilter> & {
+    [K in ContentPublicFieldName<TDefinition> & PublicFilterableContentFieldName<TDefinition>]: ContentFieldInput<ContentFieldsOf<TDefinition>[K]>;
+}>;
+export type ContentPublicOrderableFieldName<TDefinition> = "publishedAt" | PublicFlatName<ContentPublicFieldName<TDefinition>>;
+export {};
+//# sourceMappingURL=types.d.ts.map