@datocms/cma-client 5.0.0 → 5.1.0

package/dist/types/generated/resources/Fieldset.d.ts

@@ -40,7 +40,7 @@ export default class Fieldset extends BaseResource {
      */
     rawUpdate(fieldsetId: string, body: SchemaTypes.FieldsetUpdateSchema): Promise<SchemaTypes.FieldsetUpdateTargetSchema>;
     /**
-     * List all fieldsets
+     * List all fieldsets of a model/block
      *
      * Read more: https://www.datocms.com/docs/content-management-api/resources/fieldset/instances
      *
@@ -49,7 +49,7 @@ export default class Fieldset extends BaseResource {
      */
     list(itemTypeId: string | SimpleSchemaTypes.ItemTypeData): Promise<SimpleSchemaTypes.FieldsetInstancesTargetSchema>;
     /**
-     * List all fieldsets
+     * List all fieldsets of a model/block
      *
      * Read more: https://www.datocms.com/docs/content-management-api/resources/fieldset/instances
      *

package/dist/types/generated/resources/UploadRequest.d.ts

@@ -4,7 +4,7 @@ import type * as SimpleSchemaTypes from '../SimpleSchemaTypes';
 export default class UploadRequest extends BaseResource {
     static readonly TYPE: "upload_request";
     /**
-     * Request a new upload
+     * Request a new permission to upload a file
      *
      * Read more: https://www.datocms.com/docs/content-management-api/resources/upload-request/create
      *
@@ -13,7 +13,7 @@ export default class UploadRequest extends BaseResource {
      */
     create(body: SimpleSchemaTypes.UploadRequestCreateSchema): Promise<SimpleSchemaTypes.UploadRequest>;
     /**
-     * Request a new upload
+     * Request a new permission to upload a file
      *
      * Read more: https://www.datocms.com/docs/content-management-api/resources/upload-request/create
      *

package/dist/types/index.d.ts

@@ -1,9 +1,15 @@
 export { ApiError, LogLevel, TimeoutError } from '@datocms/rest-client-utils';
-export * from './buildBlockRecord';
 export * from './buildClient';
 export { Client } from './generated/Client';
 export type { ClientConfigOptions } from './generated/Client';
 export * as Resources from './generated/resources';
 export * as SchemaTypes from './generated/SchemaTypes';
 export * as SimpleSchemaTypes from './generated/SimpleSchemaTypes';
-export * from './idUtils';
+export * from './utilities/blocks';
+export * from './utilities/buildBlockRecord';
+export * from './utilities/fieldsContainingReferences';
+export * from './utilities/fieldValueLocalization';
+export * from './utilities/id';
+export * from './utilities/recursiveBlocks';
+export * from './utilities/schemaRepository';
+export * from './utilities/structuredText';

package/dist/types/utilities/blocks.d.ts

@@ -0,0 +1,180 @@
+/**
+ * DatoCMS Block Field Value Processing Utilities
+ *
+ * This utility provides a unified interface for working with blocks embedded within DatoCMS field values.
+ * DatoCMS supports three field types that can contain blocks:
+ * - Modular Content fields: arrays of blocks
+ * - Single Block fields: a single block
+ * - Structured Text fields: complex document structures with embedded blocks
+ *
+ * The challenge this solves: Each field type stores blocks differently and requires different
+ * traversal logic, making it complex to perform operations like transformations, filtering,
+ * or searching across blocks regardless of their containing field type.
+ *
+ * This utility abstracts away these differences, providing a consistent API to:
+ * - Visit/iterate through all blocks in any field type
+ * - Transform blocks while preserving field structure
+ * - Filter blocks based on conditions
+ * - Search for specific blocks
+ * - Perform functional operations (map, reduce, some, every)
+ *
+ * All functions come in both sync and async variants to support different use cases,
+ * particularly useful when block transformations require async operations like API calls.
+ */
+import type { BlockItemInARequest } from '../fieldTypes';
+import type * as SchemaTypes from '../generated/SchemaTypes';
+import type * as SimpleSchemaTypes from '../generated/SimpleSchemaTypes';
+import { type TreePath } from './structuredText';
+/**
+ * Visit every block in a field value, calling the visitor function for each block found.
+ * Supports rich text, single block, and structured text field types.
+ *
+ * @param field - The DatoCMS field definition that determines how blocks are processed
+ * @param value - The field value containing blocks to visit
+ * @param visitor - Synchronous function called for each block. Receives the block item and its path
+ */
+export declare function nonRecursiveVisitBlocksInFieldValue(field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, visitor: (item: BlockItemInARequest, path: TreePath) => void): void;
+/**
+ * Visit every block in a field value, calling the visitor function for each block found.
+ * Supports rich text, single block, and structured text field types.
+ *
+ * @param field - The DatoCMS field definition that determines how blocks are processed
+ * @param value - The field value containing blocks to visit
+ * @param visitor - Asynchronous function called for each block. Receives the block item and its path
+ * @returns Promise that resolves when all blocks have been visited
+ */
+export declare function nonRecursiveVisitBlocksInFieldValueAsync(field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, visitor: (item: BlockItemInARequest, path: TreePath) => Promise<void>): Promise<void>;
+/**
+ * Transform blocks in a field value by applying a mapping function to each block.
+ * Creates a new field value structure with transformed blocks while preserving the original structure.
+ * Supports rich text, single block, and structured text field types.
+ *
+ * @param field - The DatoCMS field definition that determines how blocks are processed
+ * @param value - The field value containing blocks to transform
+ * @param mapper - Synchronous function that transforms each block. Receives block item and path, returns new block
+ * @returns The new field value with transformed blocks
+ */
+export declare function nonRecursiveMapBlocksInFieldValue(field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, mapper: (item: BlockItemInARequest, path: TreePath) => BlockItemInARequest): unknown;
+/**
+ * Transform blocks in a field value by applying a mapping function to each block.
+ * Creates a new field value structure with transformed blocks while preserving the original structure.
+ * Supports rich text, single block, and structured text field types.
+ *
+ * @param field - The DatoCMS field definition that determines how blocks are processed
+ * @param value - The field value containing blocks to transform
+ * @param mapper - Asynchronous function that transforms each block. Receives block item and path, returns new block
+ * @returns Promise that resolves to the new field value with transformed blocks
+ */
+export declare function nonRecursiveMapBlocksInFieldValueAsync(field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, mapper: (item: BlockItemInARequest, path: TreePath) => Promise<BlockItemInARequest>): Promise<unknown>;
+/**
+ * Find all blocks that match the predicate function.
+ * Searches through all blocks in the field value and returns all matches.
+ *
+ * @param field - The DatoCMS field definition that determines how blocks are processed
+ * @param value - The field value containing blocks to search
+ * @param predicate - Synchronous function that tests each block. Should return true for matching blocks
+ * @returns Array of objects, each containing a matching block and its path
+ */
+export declare function nonRecursiveFindAllBlocksInFieldValue(field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, predicate: (item: BlockItemInARequest, path: TreePath) => boolean): Array<{
+    item: BlockItemInARequest;
+    path: TreePath;
+}>;
+/**
+ * Find all blocks that match the predicate function.
+ * Searches through all blocks in the field value and returns all matches.
+ *
+ * @param field - The DatoCMS field definition that determines how blocks are processed
+ * @param value - The field value containing blocks to search
+ * @param predicate - Asynchronous function that tests each block. Should return true for matching blocks
+ * @returns Promise that resolves to an array of objects, each containing a matching block and its path
+ */
+export declare function nonRecursiveFindAllBlocksInFieldValueAsync(field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, predicate: (item: BlockItemInARequest, path: TreePath) => Promise<boolean>): Promise<Array<{
+    item: BlockItemInARequest;
+    path: TreePath;
+}>>;
+/**
+ * Filter blocks in a field value, removing those that don't match the predicate.
+ * Creates a new field value containing only blocks that pass the predicate test.
+ * Preserves the original field value structure and hierarchy.
+ *
+ * @param field - The DatoCMS field definition that determines how blocks are processed
+ * @param value - The field value containing blocks to filter
+ * @param predicate - Synchronous function that tests each block. Blocks returning false are removed
+ * @returns The new field value with filtered blocks
+ */
+export declare function nonRecursiveFilterBlocksInFieldValue(field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, predicate: (item: BlockItemInARequest, path: TreePath) => boolean): unknown;
+/**
+ * Filter blocks in a field value, removing those that don't match the predicate.
+ * Creates a new field value containing only blocks that pass the predicate test.
+ * Preserves the original field value structure and hierarchy.
+ *
+ * @param field - The DatoCMS field definition that determines how blocks are processed
+ * @param value - The field value containing blocks to filter
+ * @param predicate - Asynchronous function that tests each block. Blocks returning false are removed
+ * @returns Promise that resolves to the new field value with filtered blocks
+ */
+export declare function nonRecursiveFilterBlocksInFieldValueAsync(field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, predicate: (item: BlockItemInARequest, path: TreePath) => Promise<boolean>): Promise<unknown>;
+/**
+ * Reduce all blocks in a field value to a single value by applying a reducer function.
+ * Processes each block in the field value and accumulates the results into a single value.
+ *
+ * @template R - The type of the accumulated result
+ * @param field - The DatoCMS field definition that determines how blocks are processed
+ * @param value - The field value containing blocks to reduce
+ * @param reducer - Synchronous function that processes each block and updates the accumulator
+ * @param initialValue - The initial value for the accumulator
+ * @returns The final accumulated value
+ */
+export declare function nonRecursiveReduceBlocksInFieldValue<R>(field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, reducer: (accumulator: R, item: BlockItemInARequest, path: TreePath) => R, initialValue: R): R;
+/**
+ * Reduce all blocks in a field value to a single value by applying a reducer function.
+ * Processes each block in the field value and accumulates the results into a single value.
+ *
+ * @template R - The type of the accumulated result
+ * @param field - The DatoCMS field definition that determines how blocks are processed
+ * @param value - The field value containing blocks to reduce
+ * @param reducer - Asynchronous function that processes each block and updates the accumulator
+ * @param initialValue - The initial value for the accumulator
+ * @returns Promise that resolves to the final accumulated value
+ */
+export declare function nonRecursiveReduceBlocksInFieldValueAsync<R>(field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, reducer: (accumulator: R, item: BlockItemInARequest, path: TreePath) => Promise<R>, initialValue: R): Promise<R>;
+/**
+ * Check if any block in the field value matches the predicate function.
+ * Returns true as soon as the first matching block is found (short-circuit evaluation).
+ *
+ * @param field - The DatoCMS field definition that determines how blocks are processed
+ * @param value - The field value containing blocks to test
+ * @param predicate - Synchronous function that tests each block. Should return true for matching blocks
+ * @returns True if any block matches, false otherwise
+ */
+export declare function nonRecursiveSomeBlocksInFieldValue(field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, predicate: (item: BlockItemInARequest, path: TreePath) => boolean): boolean;
+/**
+ * Check if any block in the field value matches the predicate function.
+ * Returns true as soon as the first matching block is found (short-circuit evaluation).
+ *
+ * @param field - The DatoCMS field definition that determines how blocks are processed
+ * @param value - The field value containing blocks to test
+ * @param predicate - Asynchronous function that tests each block. Should return true for matching blocks
+ * @returns Promise that resolves to true if any block matches, false otherwise
+ */
+export declare function nonRecursiveSomeBlocksInFieldValueAsync(field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, predicate: (item: BlockItemInARequest, path: TreePath) => Promise<boolean>): Promise<boolean>;
+/**
+ * Check if every block in the field value matches the predicate function.
+ * Returns false as soon as the first non-matching block is found (short-circuit evaluation).
+ *
+ * @param field - The DatoCMS field definition that determines how blocks are processed
+ * @param value - The field value containing blocks to test
+ * @param predicate - Synchronous function that tests each block. Should return true for valid blocks
+ * @returns True if all blocks match, false otherwise
+ */
+export declare function nonRecursiveEveryBlockInFieldValue(field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, predicate: (item: BlockItemInARequest, path: TreePath) => boolean): boolean;
+/**
+ * Check if every block in the field value matches the predicate function.
+ * Returns false as soon as the first non-matching block is found (short-circuit evaluation).
+ *
+ * @param field - The DatoCMS field definition that determines how blocks are processed
+ * @param value - The field value containing blocks to test
+ * @param predicate - Asynchronous function that tests each block. Should return true for valid blocks
+ * @returns Promise that resolves to true if all blocks match, false otherwise
+ */
+export declare function nonRecursiveEveryBlockInFieldValueAsync(field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, predicate: (item: BlockItemInARequest, path: TreePath) => Promise<boolean>): Promise<boolean>;

package/dist/types/{buildBlockRecord.d.ts → utilities/buildBlockRecord.d.ts}

@@ -1,5 +1,5 @@
-import type * as SchemaTypes from './generated/SchemaTypes';
-import type * as SimpleSchemaTypes from './generated/SimpleSchemaTypes';
+import type * as SchemaTypes from '../generated/SchemaTypes';
+import type * as SimpleSchemaTypes from '../generated/SimpleSchemaTypes';
 export declare function buildBlockRecord(body: SimpleSchemaTypes.ItemUpdateSchema): {
     type: "item";
     id: string;

package/dist/types/utilities/fieldValueLocalization.d.ts

@@ -0,0 +1,123 @@
+import type * as SchemaTypes from '../generated/SchemaTypes';
+import type * as SimpleSchemaTypes from '../generated/SimpleSchemaTypes';
+/**
+ * In DatoCMS, fields can be localized. In this scenario, their value contains values
+ * for various locales structured as an object, such as
+ `{ "en": "Hello", "it": "Ciao" }`)
+ */
+export type LocalizedFieldValue = Record<string, unknown>;
+export declare function isLocalized(field: SchemaTypes.Field | SimpleSchemaTypes.Field): boolean;
+/**
+ * Maps localized field values using a provided mapping function.
+ * For localized fields, applies the mapping function to each locale value.
+ * For non-localized fields, applies the mapping function directly to the only non-localizeed value.
+ *
+ * @template T - The type that the mapping function returns
+ * @param field - The DatoCMS field definition
+ * @param value - The field value (either localized object or direct value)
+ * @param mapFn - The function to apply to each locale value or the direct value
+ * @returns The mapped value with the same structure as the input
+ */
+export declare function mapLocalizedFieldValues<T>(field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, mapFn: (locale: string | undefined, localeValue: unknown) => T): T | {
+    [k: string]: T;
+};
+/**
+ * Maps localized field values using a provided mapping function (async version).
+ * For localized fields, applies the mapping function to each locale value.
+ * For non-localized fields, applies the mapping function directly to the only non-localizeed value.
+ *
+ * @template T - The type that the mapping function returns
+ * @param field - The DatoCMS field definition
+ * @param value - The field value (either localized object or direct value)
+ * @param mapFn - The function to apply to each locale value or the direct value
+ * @returns The mapped value with the same structure as the input
+ */
+export declare function mapLocalizedFieldValuesAsync<T>(field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, mapFn: (locale: string | undefined, localeValue: unknown) => Promise<T>): Promise<T | {
+    [k: string]: unknown;
+}>;
+/**
+ * Filters localized field values using a provided filter function.
+ * For localized fields, filters each locale value.
+ * For non-localized fields, returns the value if the filter passes, otherwise undefined.
+ *
+ * @param field - The DatoCMS field definition
+ * @param value - The field value (either localized object or direct value)
+ * @param filterFn - The function to test each locale value or the direct value
+ * @returns The filtered value with the same structure as the input
+ */
+export declare function filterLocalizedFieldValues(field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, filterFn: (locale: string | undefined, localeValue: unknown) => boolean): unknown;
+/**
+ * Filters localized field values using a provided filter function (async version).
+ * For localized fields, filters each locale value.
+ * For non-localized fields, returns the value if the filter passes, otherwise undefined.
+ *
+ * @param field - The DatoCMS field definition
+ * @param value - The field value (either localized object or direct value)
+ * @param filterFn - The function to test each locale value or the direct value
+ * @returns The filtered value with the same structure as the input
+ */
+export declare function filterLocalizedFieldValuesAsync(field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, filterFn: (locale: string | undefined, localeValue: unknown) => Promise<boolean>): Promise<unknown>;
+/**
+ * Tests whether at least one localized field value passes the test implemented by the provided function.
+ * For localized fields, tests each locale value.
+ * For non-localized fields, tests the direct value.
+ *
+ * @param field - The DatoCMS field definition
+ * @param value - The field value (either localized object or direct value)
+ * @param testFn - The function to test each locale value or the direct value
+ * @returns true if at least one value passes the test, false otherwise
+ */
+export declare function someLocalizedFieldValues(field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, testFn: (locale: string | undefined, localeValue: unknown) => boolean): boolean;
+/**
+ * Tests whether at least one localized field value passes the test implemented by the provided function (async version).
+ * For localized fields, tests each locale value.
+ * For non-localized fields, tests the direct value.
+ *
+ * @param field - The DatoCMS field definition
+ * @param value - The field value (either localized object or direct value)
+ * @param testFn - The function to test each locale value or the direct value
+ * @returns true if at least one value passes the test, false otherwise
+ */
+export declare function someLocalizedFieldValuesAsync(field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, testFn: (locale: string | undefined, localeValue: unknown) => Promise<boolean>): Promise<boolean>;
+/**
+ * Tests whether all localized field values pass the test implemented by the provided function.
+ * For localized fields, tests each locale value.
+ * For non-localized fields, tests the direct value.
+ *
+ * @param field - The DatoCMS field definition
+ * @param value - The field value (either localized object or direct value)
+ * @param testFn - The function to test each locale value or the direct value
+ * @returns true if all values pass the test, false otherwise
+ */
+export declare function everyLocalizedFieldValues(field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, testFn: (locale: string | undefined, localeValue: unknown) => boolean): boolean;
+/**
+ * Tests whether all localized field values pass the test implemented by the provided function (async version).
+ * For localized fields, tests each locale value.
+ * For non-localized fields, tests the direct value.
+ *
+ * @param field - The DatoCMS field definition
+ * @param value - The field value (either localized object or direct value)
+ * @param testFn - The function to test each locale value or the direct value
+ * @returns true if all values pass the test, false otherwise
+ */
+export declare function everyLocalizedFieldValuesAsync(field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, testFn: (locale: string | undefined, localeValue: unknown) => Promise<boolean>): Promise<boolean>;
+/**
+ * Visits each localized field value with the provided function.
+ * For localized fields, visits each locale value.
+ * For non-localized fields, visits the direct value.
+ *
+ * @param field - The DatoCMS field definition
+ * @param value - The field value (either localized object or direct value)
+ * @param visitFn - The function to call for each locale value or the direct value
+ */
+export declare function visitLocalizedFieldValues(field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, visitFn: (locale: string | undefined, localeValue: unknown) => void): void;
+/**
+ * Visits each localized field value with the provided function (async version).
+ * For localized fields, visits each locale value.
+ * For non-localized fields, visits the direct value.
+ *
+ * @param field - The DatoCMS field definition
+ * @param value - The field value (either localized object or direct value)
+ * @param visitFn - The function to call for each locale value or the direct value
+ */
+export declare function visitLocalizedFieldValuesAsync(field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, visitFn: (locale: string | undefined, localeValue: unknown) => Promise<void>): Promise<void>;

package/dist/types/utilities/fieldsContainingReferences.d.ts

@@ -0,0 +1,4 @@
+import type * as SchemaTypes from '../generated/SchemaTypes';
+import type * as SimpleSchemaTypes from '../generated/SimpleSchemaTypes';
+export declare function modelIdsReferencedInField(field: SchemaTypes.Field | SimpleSchemaTypes.Field): string[];
+export declare function blockModelIdsReferencedInField(field: SchemaTypes.Field | SimpleSchemaTypes.Field): string[];

package/dist/types/utilities/recursiveBlocks.d.ts

@@ -0,0 +1,15 @@
+import { type BlockItemInARequest } from '../fieldTypes';
+import type * as SchemaTypes from '../generated/SchemaTypes';
+import type * as SimpleSchemaTypes from '../generated/SimpleSchemaTypes';
+import type { SchemaRepository } from './schemaRepository';
+import type { TreePath } from './structuredText';
+export declare function visitBlocksInFieldValues(schemaRepository: SchemaRepository, field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, visitor: (item: BlockItemInARequest, path: TreePath) => void | Promise<void>, path?: TreePath): Promise<void>;
+export declare function findAllBlocksInFieldValues(schemaRepository: SchemaRepository, field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, predicate: (item: BlockItemInARequest, path: TreePath) => boolean | Promise<boolean>, path?: TreePath): Promise<Array<{
+    item: BlockItemInARequest;
+    path: TreePath;
+}>>;
+export declare function filterBlocksInFieldValues(schemaRepository: SchemaRepository, field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, predicate: (item: BlockItemInARequest, path: TreePath) => boolean | Promise<boolean>, path?: TreePath): Promise<unknown>;
+export declare function reduceBlocksInFieldValues<R>(schemaRepository: SchemaRepository, field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, reducer: (accumulator: R, item: BlockItemInARequest, path: TreePath) => R | Promise<R>, initialValue: R, path?: TreePath): Promise<R>;
+export declare function someBlocksInFieldValues(schemaRepository: SchemaRepository, field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, predicate: (item: BlockItemInARequest, path: TreePath) => boolean | Promise<boolean>, path?: TreePath): Promise<boolean>;
+export declare function everyBlockInFieldValues(schemaRepository: SchemaRepository, field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, predicate: (item: BlockItemInARequest, path: TreePath) => boolean | Promise<boolean>, path?: TreePath): Promise<boolean>;
+export declare function mapBlocksInFieldValues(schemaRepository: SchemaRepository, field: SchemaTypes.Field | SimpleSchemaTypes.Field, value: unknown, mapper: (item: BlockItemInARequest, path: TreePath) => BlockItemInARequest | Promise<BlockItemInARequest>, path?: TreePath): Promise<unknown>;

package/dist/types/utilities/schemaRepository.d.ts

@@ -0,0 +1,181 @@
+import type * as SchemaTypes from '../generated/SchemaTypes';
+import type * as SimpleSchemaTypes from '../generated/SimpleSchemaTypes';
+interface GenericClient {
+    itemTypes: {
+        rawList(): Promise<{
+            data: SchemaTypes.ItemType[];
+        }>;
+    };
+    fields: {
+        rawList(itemTypeId: string): Promise<{
+            data: SchemaTypes.Field[];
+        }>;
+    };
+    fieldsets: {
+        rawList(itemTypeId: string): Promise<{
+            data: SchemaTypes.Fieldset[];
+        }>;
+    };
+    plugins: {
+        rawList(): Promise<{
+            data: SchemaTypes.Plugin[];
+        }>;
+    };
+}
+/**
+ * Repository for DatoCMS schema entities including item types, fields, and plugins.
+ * Provides caching and efficient lookup functionality for schema-related operations.
+ */
+export declare class SchemaRepository {
+    private client;
+    private itemTypesPromise;
+    private itemTypesByApiKey;
+    private itemTypesById;
+    private fieldsByItemType;
+    private fieldsetsByItemType;
+    private pluginsPromise;
+    private pluginsById;
+    private pluginsByPackageName;
+    /**
+     * Creates a new SchemaRepository instance.
+     * @param client - The DatoCMS client instance
+     */
+    constructor(client: GenericClient);
+    /**
+     * Loads and caches all item types from the DatoCMS API.
+     * This method is called lazily and caches the result for subsequent calls.
+     * @returns Promise that resolves to an array of item types
+     */
+    private loadItemTypes;
+    /**
+     * Gets all item types from the DatoCMS project.
+     * @returns Promise that resolves to an array of all item types
+     */
+    getAllItemTypes(): Promise<SimpleSchemaTypes.ItemType[]>;
+    /**
+     * Gets all item types from the DatoCMS project.
+     * @returns Promise that resolves to an array of all item types
+     */
+    getAllRawItemTypes(): Promise<SchemaTypes.ItemType[]>;
+    /**
+     * Gets all item types that are models (not modular blocks).
+     * @returns Promise that resolves to an array of model item types
+     */
+    getAllModels(): Promise<SimpleSchemaTypes.ItemType[]>;
+    /**
+     * Gets all item types that are models (not modular blocks).
+     * @returns Promise that resolves to an array of model item types
+     */
+    getAllRawModels(): Promise<SchemaTypes.ItemType[]>;
+    /**
+     * Gets all item types that are modular blocks.
+     * @returns Promise that resolves to an array of block model item types
+     */
+    getAllBlockModels(): Promise<SimpleSchemaTypes.ItemType[]>;
+    /**
+     * Gets all item types that are modular blocks.
+     * @returns Promise that resolves to an array of block model item types
+     */
+    getAllRawBlockModels(): Promise<SchemaTypes.ItemType[]>;
+    /**
+     * Gets an item type by its API key.
+     * @param apiKey - The API key of the item type to retrieve
+     * @returns Promise that resolves to the item type
+     * @throws Error if the item type is not found
+     */
+    getItemTypeByApiKey(apiKey: string): Promise<SimpleSchemaTypes.ItemType>;
+    /**
+     * Gets an item type by its API key.
+     * @param apiKey - The API key of the item type to retrieve
+     * @returns Promise that resolves to the item type
+     * @throws Error if the item type is not found
+     */
+    getRawItemTypeByApiKey(apiKey: string): Promise<SchemaTypes.ItemType>;
+    /**
+     * Gets an item type by its ID.
+     * @param id - The ID of the item type to retrieve
+     * @returns Promise that resolves to the item type
+     * @throws Error if the item type is not found
+     */
+    getItemTypeById(id: string): Promise<SimpleSchemaTypes.ItemType>;
+    /**
+     * Gets an item type by its ID.
+     * @param id - The ID of the item type to retrieve
+     * @returns Promise that resolves to the item type
+     * @throws Error if the item type is not found
+     */
+    getRawItemTypeById(id: string): Promise<SchemaTypes.ItemType>;
+    /**
+     * Gets all fields for a given item type.
+     * Fields are cached after the first request for performance.
+     * @param itemType - The item type to get fields for
+     * @returns Promise that resolves to an array of fields
+     */
+    getItemTypeFields(itemType: SimpleSchemaTypes.ItemType | SchemaTypes.ItemType): Promise<SimpleSchemaTypes.Field[]>;
+    /**
+     * Gets all fields for a given item type.
+     * Fields are cached after the first request for performance.
+     * @param itemType - The item type to get fields for
+     * @returns Promise that resolves to an array of fields
+     */
+    getRawItemTypeFields(itemType: SchemaTypes.ItemType): Promise<SchemaTypes.Field[]>;
+    /**
+     * Gets all fieldsets for a given item type.
+     * Fieldsets are cached after the first request for performance.
+     * @param itemType - The item type to get fieldsets for
+     * @returns Promise that resolves to an array of fieldsets
+     */
+    getItemTypeFieldsets(itemType: SimpleSchemaTypes.ItemType | SchemaTypes.ItemType): Promise<SimpleSchemaTypes.Fieldset[]>;
+    /**
+     * Gets all fieldsets for a given item type.
+     * Fieldsets are cached after the first request for performance.
+     * @param itemType - The item type to get fieldsets for
+     * @returns Promise that resolves to an array of fieldsets
+     */
+    getRawItemTypeFieldsets(itemType: SchemaTypes.ItemType): Promise<SchemaTypes.Fieldset[]>;
+    /**
+     * Loads and caches all plugins from the DatoCMS API.
+     * This method is called lazily and caches the result for subsequent calls.
+     * @returns Promise that resolves to an array of plugins
+     */
+    private loadPlugins;
+    /**
+     * Gets all plugins from the DatoCMS project.
+     * @returns Promise that resolves to an array of all plugins
+     */
+    getAllPlugins(): Promise<SimpleSchemaTypes.Plugin[]>;
+    /**
+     * Gets all plugins from the DatoCMS project.
+     * @returns Promise that resolves to an array of all plugins
+     */
+    getAllRawPlugins(): Promise<SchemaTypes.Plugin[]>;
+    /**
+     * Gets a plugin by its ID.
+     * @param id - The ID of the plugin to retrieve
+     * @returns Promise that resolves to the plugin
+     * @throws Error if the plugin is not found
+     */
+    getPluginById(id: string): Promise<SimpleSchemaTypes.Plugin>;
+    /**
+     * Gets a plugin by its ID.
+     * @param id - The ID of the plugin to retrieve
+     * @returns Promise that resolves to the plugin
+     * @throws Error if the plugin is not found
+     */
+    getRawPluginById(id: string): Promise<SchemaTypes.Plugin>;
+    /**
+     * Gets a plugin by its package name.
+     * @param packageName - The package name of the plugin to retrieve
+     * @returns Promise that resolves to the plugin
+     * @throws Error if the plugin is not found
+     */
+    getPluginByPackageName(packageName: string): Promise<SimpleSchemaTypes.Plugin>;
+    /**
+     * Gets a plugin by its package name.
+     * @param packageName - The package name of the plugin to retrieve
+     * @returns Promise that resolves to the plugin
+     * @throws Error if the plugin is not found
+     */
+    getRawPluginByPackageName(packageName: string): Promise<SchemaTypes.Plugin>;
+}
+export {};