@datocms/cma-client 5.4.6 → 5.4.7

package/README.md

@@ -309,10 +309,17 @@ TypeScript doesn't auto-narrow on discriminators buried in nested properties, so
 
 **TypeScript Signature:**
 ```typescript
+// Curried — returns a predicate (use with .filter / .find)
 function isBlockOfType<Id extends string>(
   itemTypeId: Id,
 ): <T>(block: T) => block is NarrowBlockByItemType<T, Id>
 
+// Direct — checks a single block inline (use inside `if`)
+function isBlockOfType<T, Id extends string>(
+  itemTypeId: Id,
+  block: T,
+): block is NarrowBlockByItemType<T, Id>
+
 type NarrowBlockByItemType<T, Id extends string> = Extract<
   T,
   { relationships: { item_type: { data: { type: 'item_type'; id: Id } } } }
@@ -321,8 +328,13 @@ type NarrowBlockByItemType<T, Id extends string> = Extract<
 
 **Parameters:**
 - `itemTypeId`: The item-type ID literal. For narrowing to work, the argument must be typed as a literal — use `as const` on pre-set ID constants. No `ItemTypeDefinition` type parameter is needed: `Extract` walks the input union using just the ID.
+- `block` (direct form only): The block to check.
+
+**Returns:**
+- Curried form: a predicate `(block) => block is D-typed-block`.
+- Direct form: a `boolean` that also acts as a type guard on `block`.
 
-**Returns:** A predicate `(block) => block is D-typed-block` that:
+In both cases the guard:
 - Narrows blocks carrying `relationships.item_type.data.id` — that covers `BlockInNestedResponse<D>` and the object variants of `BlockInRequest<D>` (`UpdatedBlockInRequest`, `NewBlockInRequest`).
 - Returns `false` for plain string IDs (unchanged-reference form in request payloads) and for any non-block input.
 
@@ -343,12 +355,18 @@ const images = article.content.filter(
 );
 images[0].attributes.upload_id; // ❌ property does not exist on union
 
-// After: guard narrows the filter result
+// After (curried): guard narrows the filter result
 const images = article.content.filter(isBlockOfType(IMAGE_BLOCK_ID));
 images[0].attributes.upload_id; // ✅ narrowed
+
+// After (direct): inline narrowing on a single block
+const first = article.content[0];
+if (isBlockOfType(IMAGE_BLOCK_ID, first)) {
+  first.attributes.upload_id; // ✅ narrowed
+}
 ```
 
-Use the `__itemTypeId` discriminator for inline `if` / `switch` narrowing on a single value — that's simpler and doesn't need a helper. Reach for `isBlockOfType` when you need a predicate for `.filter` / `.find`.
+Use the curried form when you need a predicate for `.filter` / `.find`; use the direct form for one-off `if` checks. The `__itemTypeId` discriminator is also available for inline `switch` narrowing on a single value.
 </details>
 
 ### Recursive Block Operations

package/dist/cjs/generated/Client.js

@@ -90,7 +90,7 @@ class Client {
         return this.config.baseUrl || Client.defaultBaseUrl;
     }
     request(options) {
-        return (0, rest_client_utils_1.request)(Object.assign(Object.assign(Object.assign({}, this.config), options), { logFn: this.config.logFn || console.log, userAgent: '@datocms/cma-client v5.4.6', baseUrl: this.baseUrl, preCallStack: new Error().stack, extraHeaders: Object.assign(Object.assign(Object.assign({}, (this.config.extraHeaders || {})), (this.config.environment
+        return (0, rest_client_utils_1.request)(Object.assign(Object.assign(Object.assign({}, this.config), options), { logFn: this.config.logFn || console.log, userAgent: '@datocms/cma-client v5.4.7', baseUrl: this.baseUrl, preCallStack: new Error().stack, extraHeaders: Object.assign(Object.assign(Object.assign({}, (this.config.extraHeaders || {})), (this.config.environment
                 ? { 'X-Environment': this.config.environment }
                 : {})), { 'X-API-Version': '3' }), fetchJobResult: (jobId) => {
                 return this.jobResultsFetcher

package/dist/cjs/utilities/isBlockOfType.js

@@ -1,39 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isBlockOfType = void 0;
-/**
- * Builds a type guard that narrows a block to a specific model.
- *
- * Call it with the block's `itemTypeId` literal — the ID generic is inferred
- * from the argument, so no explicit type parameter is needed. The returned
- * predicate is generic: given any input type `T`, it narrows to
- * `Extract<T, { relationships: { item_type: { data: { id: Id } } } }>`. It's
- * meant to plug into `Array#filter` / `Array#find` over block-bearing fields
- * in any of these contexts:
- *
- * - `ItemInNestedResponse<D>` (responses with `nested: true`)
- * - `ItemCreateSchema<D>` / `ItemUpdateSchema<D>` (request payloads, object
- *   variants; plain string IDs are filtered out — there's no way to narrow
- *   them without an external lookup)
- *
- * The default (non-nested) response shape, where block fields are arrays of
- * plain string IDs, is deliberately not supported — the type information is
- * not recoverable from an ID alone.
- *
- * For the literal `Id` to be preserved (and narrowing to work), the argument
- * must be typed as a literal — use `as const` on pre-set ID constants.
- *
- * @example
- * ```ts
- * const SESSION_BLOCK_ID = 'abc123' as const;
- *
- * const record = await client.items.find<Schema.ConferenceDay>(id, { nested: true });
- * const sessions = record.agenda.filter(isBlockOfType(SESSION_BLOCK_ID));
- * sessions[0].attributes.signup_url; // OK — narrowed
- * ```
- */
-function isBlockOfType(itemTypeId) {
-    return (block) => {
+function isBlockOfType(itemTypeId, ...rest) {
+    const check = (block) => {
         if (typeof block !== 'object' || block === null)
             return false;
         const relationships = block.relationships;
@@ -47,6 +16,9 @@ function isBlockOfType(itemTypeId) {
             return false;
         return data.id === itemTypeId;
     };
+    if (rest.length > 0)
+        return check(rest[0]);
+    return (block) => check(block);
 }
 exports.isBlockOfType = isBlockOfType;
 //# sourceMappingURL=isBlockOfType.js.map

package/dist/cjs/utilities/isBlockOfType.js.map

@@ -1 +1 @@
-{"version":3,"file":"isBlockOfType.js","sourceRoot":"","sources":["../../../src/utilities/isBlockOfType.ts"],"names":[],"mappings":";;;AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,SAAgB,aAAa,CAC3B,UAAc;IAEd,OAAO,CAAI,KAAQ,EAAyC,EAAE;QAC5D,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;YAAE,OAAO,KAAK,CAAC;QAC9D,MAAM,aAAa,GAAI,KAAqC,CAAC,aAAa,CAAC;QAC3E,IAAI,OAAO,aAAa,KAAK,QAAQ,IAAI,aAAa,KAAK,IAAI;YAC7D,OAAO,KAAK,CAAC;QACf,MAAM,QAAQ,GAAI,aAAyC,CAAC,SAAS,CAAC;QACtE,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,IAAI;YAAE,OAAO,KAAK,CAAC;QACpE,MAAM,IAAI,GAAI,QAA+B,CAAC,IAAI,CAAC;QACnD,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI;YAAE,OAAO,KAAK,CAAC;QAC5D,OAAQ,IAAyB,CAAC,EAAE,KAAK,UAAU,CAAC;IACtD,CAAC,CAAC;AACJ,CAAC;AAdD,sCAcC"}
+{"version":3,"file":"isBlockOfType.js","sourceRoot":"","sources":["../../../src/utilities/isBlockOfType.ts"],"names":[],"mappings":";;;AAiEA,SAAgB,aAAa,CAC3B,UAAc,EACd,GAAG,IAA2B;IAE9B,MAAM,KAAK,GAAG,CAAC,KAAc,EAAW,EAAE;QACxC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;YAAE,OAAO,KAAK,CAAC;QAC9D,MAAM,aAAa,GAAI,KAAqC,CAAC,aAAa,CAAC;QAC3E,IAAI,OAAO,aAAa,KAAK,QAAQ,IAAI,aAAa,KAAK,IAAI;YAC7D,OAAO,KAAK,CAAC;QACf,MAAM,QAAQ,GAAI,aAAyC,CAAC,SAAS,CAAC;QACtE,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,IAAI;YAAE,OAAO,KAAK,CAAC;QACpE,MAAM,IAAI,GAAI,QAA+B,CAAC,IAAI,CAAC;QACnD,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI;YAAE,OAAO,KAAK,CAAC;QAC5D,OAAQ,IAAyB,CAAC,EAAE,KAAK,UAAU,CAAC;IACtD,CAAC,CAAC;IACF,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3C,OAAO,CAAI,KAAQ,EAAyC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;AAC9E,CAAC;AAjBD,sCAiBC"}

package/dist/esm/generated/Client.js

@@ -64,7 +64,7 @@ export class Client {
         return this.config.baseUrl || Client.defaultBaseUrl;
     }
     request(options) {
-        return request(Object.assign(Object.assign(Object.assign({}, this.config), options), { logFn: this.config.logFn || console.log, userAgent: '@datocms/cma-client v5.4.6', baseUrl: this.baseUrl, preCallStack: new Error().stack, extraHeaders: Object.assign(Object.assign(Object.assign({}, (this.config.extraHeaders || {})), (this.config.environment
+        return request(Object.assign(Object.assign(Object.assign({}, this.config), options), { logFn: this.config.logFn || console.log, userAgent: '@datocms/cma-client v5.4.7', baseUrl: this.baseUrl, preCallStack: new Error().stack, extraHeaders: Object.assign(Object.assign(Object.assign({}, (this.config.extraHeaders || {})), (this.config.environment
                 ? { 'X-Environment': this.config.environment }
                 : {})), { 'X-API-Version': '3' }), fetchJobResult: (jobId) => {
                 return this.jobResultsFetcher

package/dist/esm/utilities/isBlockOfType.d.ts

@@ -19,14 +19,19 @@ export type NarrowBlockByItemType<T, Id extends string> = Extract<T, {
     };
 }>;
 /**
- * Builds a type guard that narrows a block to a specific model.
+ * Type guard that narrows a block to a specific model.
  *
- * Call it with the block's `itemTypeId` literal — the ID generic is inferred
- * from the argument, so no explicit type parameter is needed. The returned
- * predicate is generic: given any input type `T`, it narrows to
- * `Extract<T, { relationships: { item_type: { data: { id: Id } } } }>`. It's
- * meant to plug into `Array#filter` / `Array#find` over block-bearing fields
- * in any of these contexts:
+ * Two call styles, same narrowing behavior:
+ *
+ * - Curried: `isBlockOfType(itemTypeId)` returns a predicate, ideal for
+ *   `Array#filter` / `Array#find`.
+ * - Direct: `isBlockOfType(itemTypeId, block)` checks a single value inline,
+ *   handy inside `if` statements when you already have the block in hand.
+ *
+ * The ID generic is inferred from the first argument, so no explicit type
+ * parameter is needed. Given any input type `T`, the result narrows to
+ * `Extract<T, { relationships: { item_type: { data: { id: Id } } } }>`,
+ * which covers:
  *
  * - `ItemInNestedResponse<D>` (responses with `nested: true`)
  * - `ItemCreateSchema<D>` / `ItemUpdateSchema<D>` (request payloads, object
@@ -45,8 +50,16 @@ export type NarrowBlockByItemType<T, Id extends string> = Extract<T, {
  * const SESSION_BLOCK_ID = 'abc123' as const;
  *
  * const record = await client.items.find<Schema.ConferenceDay>(id, { nested: true });
+ *
+ * // Curried — predicate for filter/find
  * const sessions = record.agenda.filter(isBlockOfType(SESSION_BLOCK_ID));
  * sessions[0].attributes.signup_url; // OK — narrowed
+ *
+ * // Direct — inline check on a single block
+ * if (isBlockOfType(SESSION_BLOCK_ID, record.agenda[0])) {
+ *   record.agenda[0].attributes.signup_url; // OK — narrowed
+ * }
  * ```
  */
 export declare function isBlockOfType<Id extends string>(itemTypeId: Id): <T>(block: T) => block is NarrowBlockByItemType<T, Id>;
+export declare function isBlockOfType<T, Id extends string>(itemTypeId: Id, block: T): block is NarrowBlockByItemType<T, Id>;

package/dist/esm/utilities/isBlockOfType.js

@@ -1,36 +1,5 @@
-/**
- * Builds a type guard that narrows a block to a specific model.
- *
- * Call it with the block's `itemTypeId` literal — the ID generic is inferred
- * from the argument, so no explicit type parameter is needed. The returned
- * predicate is generic: given any input type `T`, it narrows to
- * `Extract<T, { relationships: { item_type: { data: { id: Id } } } }>`. It's
- * meant to plug into `Array#filter` / `Array#find` over block-bearing fields
- * in any of these contexts:
- *
- * - `ItemInNestedResponse<D>` (responses with `nested: true`)
- * - `ItemCreateSchema<D>` / `ItemUpdateSchema<D>` (request payloads, object
- *   variants; plain string IDs are filtered out — there's no way to narrow
- *   them without an external lookup)
- *
- * The default (non-nested) response shape, where block fields are arrays of
- * plain string IDs, is deliberately not supported — the type information is
- * not recoverable from an ID alone.
- *
- * For the literal `Id` to be preserved (and narrowing to work), the argument
- * must be typed as a literal — use `as const` on pre-set ID constants.
- *
- * @example
- * ```ts
- * const SESSION_BLOCK_ID = 'abc123' as const;
- *
- * const record = await client.items.find<Schema.ConferenceDay>(id, { nested: true });
- * const sessions = record.agenda.filter(isBlockOfType(SESSION_BLOCK_ID));
- * sessions[0].attributes.signup_url; // OK — narrowed
- * ```
- */
-export function isBlockOfType(itemTypeId) {
-    return (block) => {
+export function isBlockOfType(itemTypeId, ...rest) {
+    const check = (block) => {
         if (typeof block !== 'object' || block === null)
             return false;
         const relationships = block.relationships;
@@ -44,5 +13,8 @@ export function isBlockOfType(itemTypeId) {
             return false;
         return data.id === itemTypeId;
     };
+    if (rest.length > 0)
+        return check(rest[0]);
+    return (block) => check(block);
 }
 //# sourceMappingURL=isBlockOfType.js.map

package/dist/esm/utilities/isBlockOfType.js.map

@@ -1 +1 @@
-{"version":3,"file":"isBlockOfType.js","sourceRoot":"","sources":["../../../src/utilities/isBlockOfType.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,UAAU,aAAa,CAC3B,UAAc;IAEd,OAAO,CAAI,KAAQ,EAAyC,EAAE;QAC5D,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;YAAE,OAAO,KAAK,CAAC;QAC9D,MAAM,aAAa,GAAI,KAAqC,CAAC,aAAa,CAAC;QAC3E,IAAI,OAAO,aAAa,KAAK,QAAQ,IAAI,aAAa,KAAK,IAAI;YAC7D,OAAO,KAAK,CAAC;QACf,MAAM,QAAQ,GAAI,aAAyC,CAAC,SAAS,CAAC;QACtE,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,IAAI;YAAE,OAAO,KAAK,CAAC;QACpE,MAAM,IAAI,GAAI,QAA+B,CAAC,IAAI,CAAC;QACnD,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI;YAAE,OAAO,KAAK,CAAC;QAC5D,OAAQ,IAAyB,CAAC,EAAE,KAAK,UAAU,CAAC;IACtD,CAAC,CAAC;AACJ,CAAC"}
+{"version":3,"file":"isBlockOfType.js","sourceRoot":"","sources":["../../../src/utilities/isBlockOfType.ts"],"names":[],"mappings":"AAiEA,MAAM,UAAU,aAAa,CAC3B,UAAc,EACd,GAAG,IAA2B;IAE9B,MAAM,KAAK,GAAG,CAAC,KAAc,EAAW,EAAE;QACxC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;YAAE,OAAO,KAAK,CAAC;QAC9D,MAAM,aAAa,GAAI,KAAqC,CAAC,aAAa,CAAC;QAC3E,IAAI,OAAO,aAAa,KAAK,QAAQ,IAAI,aAAa,KAAK,IAAI;YAC7D,OAAO,KAAK,CAAC;QACf,MAAM,QAAQ,GAAI,aAAyC,CAAC,SAAS,CAAC;QACtE,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,IAAI;YAAE,OAAO,KAAK,CAAC;QACpE,MAAM,IAAI,GAAI,QAA+B,CAAC,IAAI,CAAC;QACnD,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI;YAAE,OAAO,KAAK,CAAC;QAC5D,OAAQ,IAAyB,CAAC,EAAE,KAAK,UAAU,CAAC;IACtD,CAAC,CAAC;IACF,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3C,OAAO,CAAI,KAAQ,EAAyC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;AAC9E,CAAC"}

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

@@ -19,14 +19,19 @@ export type NarrowBlockByItemType<T, Id extends string> = Extract<T, {
     };
 }>;
 /**
- * Builds a type guard that narrows a block to a specific model.
+ * Type guard that narrows a block to a specific model.
  *
- * Call it with the block's `itemTypeId` literal — the ID generic is inferred
- * from the argument, so no explicit type parameter is needed. The returned
- * predicate is generic: given any input type `T`, it narrows to
- * `Extract<T, { relationships: { item_type: { data: { id: Id } } } }>`. It's
- * meant to plug into `Array#filter` / `Array#find` over block-bearing fields
- * in any of these contexts:
+ * Two call styles, same narrowing behavior:
+ *
+ * - Curried: `isBlockOfType(itemTypeId)` returns a predicate, ideal for
+ *   `Array#filter` / `Array#find`.
+ * - Direct: `isBlockOfType(itemTypeId, block)` checks a single value inline,
+ *   handy inside `if` statements when you already have the block in hand.
+ *
+ * The ID generic is inferred from the first argument, so no explicit type
+ * parameter is needed. Given any input type `T`, the result narrows to
+ * `Extract<T, { relationships: { item_type: { data: { id: Id } } } }>`,
+ * which covers:
  *
  * - `ItemInNestedResponse<D>` (responses with `nested: true`)
  * - `ItemCreateSchema<D>` / `ItemUpdateSchema<D>` (request payloads, object
@@ -45,8 +50,16 @@ export type NarrowBlockByItemType<T, Id extends string> = Extract<T, {
  * const SESSION_BLOCK_ID = 'abc123' as const;
  *
  * const record = await client.items.find<Schema.ConferenceDay>(id, { nested: true });
+ *
+ * // Curried — predicate for filter/find
  * const sessions = record.agenda.filter(isBlockOfType(SESSION_BLOCK_ID));
  * sessions[0].attributes.signup_url; // OK — narrowed
+ *
+ * // Direct — inline check on a single block
+ * if (isBlockOfType(SESSION_BLOCK_ID, record.agenda[0])) {
+ *   record.agenda[0].attributes.signup_url; // OK — narrowed
+ * }
  * ```
  */
 export declare function isBlockOfType<Id extends string>(itemTypeId: Id): <T>(block: T) => block is NarrowBlockByItemType<T, Id>;
+export declare function isBlockOfType<T, Id extends string>(itemTypeId: Id, block: T): block is NarrowBlockByItemType<T, Id>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datocms/cma-client",
-  "version": "5.4.6",
+  "version": "5.4.7",
   "description": "JS client for DatoCMS REST Content Management API",
   "keywords": [
     "datocms",
@@ -45,5 +45,5 @@
     "@datocms/dashboard-client": "^5.4.3",
     "@types/uuid": "^9.0.7"
   },
-  "gitHead": "6463b1003aeaabc216b2d1a17a654c444f16155a"
+  "gitHead": "4a2443c6f351448a165eef4359a3451ffd5b6b08"
 }

package/src/generated/Client.ts

@@ -151,7 +151,7 @@ export class Client {
       ...this.config,
       ...options,
       logFn: this.config.logFn || console.log,
-      userAgent: '@datocms/cma-client v5.4.6',
+      userAgent: '@datocms/cma-client v5.4.7',
       baseUrl: this.baseUrl,
       preCallStack: new Error().stack,
       extraHeaders: {

package/src/utilities/isBlockOfType.ts

@@ -14,14 +14,19 @@ export type NarrowBlockByItemType<T, Id extends string> = Extract<
 >;
 
 /**
- * Builds a type guard that narrows a block to a specific model.
+ * Type guard that narrows a block to a specific model.
  *
- * Call it with the block's `itemTypeId` literal — the ID generic is inferred
- * from the argument, so no explicit type parameter is needed. The returned
- * predicate is generic: given any input type `T`, it narrows to
- * `Extract<T, { relationships: { item_type: { data: { id: Id } } } }>`. It's
- * meant to plug into `Array#filter` / `Array#find` over block-bearing fields
- * in any of these contexts:
+ * Two call styles, same narrowing behavior:
+ *
+ * - Curried: `isBlockOfType(itemTypeId)` returns a predicate, ideal for
+ *   `Array#filter` / `Array#find`.
+ * - Direct: `isBlockOfType(itemTypeId, block)` checks a single value inline,
+ *   handy inside `if` statements when you already have the block in hand.
+ *
+ * The ID generic is inferred from the first argument, so no explicit type
+ * parameter is needed. Given any input type `T`, the result narrows to
+ * `Extract<T, { relationships: { item_type: { data: { id: Id } } } }>`,
+ * which covers:
  *
  * - `ItemInNestedResponse<D>` (responses with `nested: true`)
  * - `ItemCreateSchema<D>` / `ItemUpdateSchema<D>` (request payloads, object
@@ -40,14 +45,29 @@ export type NarrowBlockByItemType<T, Id extends string> = Extract<
  * const SESSION_BLOCK_ID = 'abc123' as const;
  *
  * const record = await client.items.find<Schema.ConferenceDay>(id, { nested: true });
+ *
+ * // Curried — predicate for filter/find
  * const sessions = record.agenda.filter(isBlockOfType(SESSION_BLOCK_ID));
  * sessions[0].attributes.signup_url; // OK — narrowed
+ *
+ * // Direct — inline check on a single block
+ * if (isBlockOfType(SESSION_BLOCK_ID, record.agenda[0])) {
+ *   record.agenda[0].attributes.signup_url; // OK — narrowed
+ * }
  * ```
  */
 export function isBlockOfType<Id extends string>(
   itemTypeId: Id,
-): <T>(block: T) => block is NarrowBlockByItemType<T, Id> {
-  return <T>(block: T): block is NarrowBlockByItemType<T, Id> => {
+): <T>(block: T) => block is NarrowBlockByItemType<T, Id>;
+export function isBlockOfType<T, Id extends string>(
+  itemTypeId: Id,
+  block: T,
+): block is NarrowBlockByItemType<T, Id>;
+export function isBlockOfType<Id extends string>(
+  itemTypeId: Id,
+  ...rest: [block: unknown] | []
+): boolean | (<T>(block: T) => block is NarrowBlockByItemType<T, Id>) {
+  const check = (block: unknown): boolean => {
     if (typeof block !== 'object' || block === null) return false;
     const relationships = (block as { relationships?: unknown }).relationships;
     if (typeof relationships !== 'object' || relationships === null)
@@ -58,4 +78,6 @@ export function isBlockOfType<Id extends string>(
     if (typeof data !== 'object' || data === null) return false;
     return (data as { id?: unknown }).id === itemTypeId;
   };
+  if (rest.length > 0) return check(rest[0]);
+  return <T>(block: T): block is NarrowBlockByItemType<T, Id> => check(block);
 }