@nuxtseo/protocol 0.1.0

package/dist/v1/account.d.ts

@@ -0,0 +1,715 @@
+import type { z } from 'zod';
+export declare const usageMeterGroupSchema: z.ZodEnum<{
+    capacity: "capacity";
+    compute: "compute";
+    integrations: "integrations";
+}>;
+export declare const usageUpgradeTierSchema: z.ZodEnum<{
+    agency: "agency";
+    free: "free";
+    full: "full";
+    lifetime: "lifetime";
+    pro: "pro";
+    search: "search";
+}>;
+export declare const usagePlanSchema: z.ZodEnum<{
+    agency: "agency";
+    free: "free";
+    full: "full";
+    lifetime: "lifetime";
+    pro: "pro";
+    search: "search";
+}>;
+export declare const accountUsageQuerySchema: z.ZodObject<{
+    group: z.ZodOptional<z.ZodEnum<{
+        capacity: "capacity";
+        compute: "compute";
+        integrations: "integrations";
+    }>>;
+}, z.core.$strict>;
+export declare const usageMeterProducerSchema: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodString;
+    group: z.ZodEnum<{
+        capacity: "capacity";
+        compute: "compute";
+        integrations: "integrations";
+    }>;
+    unit: z.ZodString;
+    used: z.ZodNumber;
+    limit: z.ZodNullable<z.ZodNumber>;
+    blocked: z.ZodBoolean;
+    overCap: z.ZodBoolean;
+    resetsAt: z.ZodNullable<z.ZodISODateTime>;
+    upgradeCopy: z.ZodArray<z.ZodObject<{
+        tier: z.ZodEnum<{
+            agency: "agency";
+            free: "free";
+            full: "full";
+            lifetime: "lifetime";
+            pro: "pro";
+            search: "search";
+        }>;
+        gain: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const usageMeterClientSchema: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodString;
+    group: z.ZodEnum<{
+        capacity: "capacity";
+        compute: "compute";
+        integrations: "integrations";
+    }>;
+    unit: z.ZodString;
+    used: z.ZodNumber;
+    limit: z.ZodNullable<z.ZodNumber>;
+    blocked: z.ZodBoolean;
+    overCap: z.ZodBoolean;
+    resetsAt: z.ZodNullable<z.ZodISODateTime>;
+    upgradeCopy: z.ZodArray<z.ZodObject<{
+        tier: z.ZodEnum<{
+            agency: "agency";
+            free: "free";
+            full: "full";
+            lifetime: "lifetime";
+            pro: "pro";
+            search: "search";
+        }>;
+        gain: z.ZodString;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export declare const accountUsageDataSchema: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+    readonly plan: z.ZodEnum<{
+        agency: "agency";
+        free: "free";
+        full: "full";
+        lifetime: "lifetime";
+        pro: "pro";
+        search: "search";
+    }>;
+    readonly meters: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodString;
+        group: z.ZodEnum<{
+            capacity: "capacity";
+            compute: "compute";
+            integrations: "integrations";
+        }>;
+        unit: z.ZodString;
+        used: z.ZodNumber;
+        limit: z.ZodNullable<z.ZodNumber>;
+        blocked: z.ZodBoolean;
+        overCap: z.ZodBoolean;
+        resetsAt: z.ZodNullable<z.ZodISODateTime>;
+        upgradeCopy: z.ZodArray<z.ZodObject<{
+            tier: z.ZodEnum<{
+                agency: "agency";
+                free: "free";
+                full: "full";
+                lifetime: "lifetime";
+                pro: "pro";
+                search: "search";
+            }>;
+            gain: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strip>, z.ZodObject<{
+    readonly plan: z.ZodEnum<{
+        agency: "agency";
+        free: "free";
+        full: "full";
+        lifetime: "lifetime";
+        pro: "pro";
+        search: "search";
+    }>;
+    readonly meters: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodString;
+        group: z.ZodEnum<{
+            capacity: "capacity";
+            compute: "compute";
+            integrations: "integrations";
+        }>;
+        unit: z.ZodString;
+        used: z.ZodNumber;
+        limit: z.ZodNullable<z.ZodNumber>;
+        blocked: z.ZodBoolean;
+        overCap: z.ZodBoolean;
+        resetsAt: z.ZodNullable<z.ZodISODateTime>;
+        upgradeCopy: z.ZodArray<z.ZodObject<{
+            tier: z.ZodEnum<{
+                agency: "agency";
+                free: "free";
+                full: "full";
+                lifetime: "lifetime";
+                pro: "pro";
+                search: "search";
+            }>;
+            gain: z.ZodString;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+}, z.core.$strip>>;
+export declare const accountUsageMetaSchema: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+    readonly requestId: z.ZodString;
+    readonly version: z.ZodLiteral<"1.0">;
+    readonly total: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    readonly requestId: z.ZodString;
+    readonly version: z.ZodLiteral<"1.0">;
+    readonly total: z.ZodNumber;
+}, z.core.$strip>>;
+export declare const accountUsageResponseSchema: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+    data: z.ZodObject<{
+        readonly plan: z.ZodEnum<{
+            agency: "agency";
+            free: "free";
+            full: "full";
+            lifetime: "lifetime";
+            pro: "pro";
+            search: "search";
+        }>;
+        readonly meters: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodString;
+            group: z.ZodEnum<{
+                capacity: "capacity";
+                compute: "compute";
+                integrations: "integrations";
+            }>;
+            unit: z.ZodString;
+            used: z.ZodNumber;
+            limit: z.ZodNullable<z.ZodNumber>;
+            blocked: z.ZodBoolean;
+            overCap: z.ZodBoolean;
+            resetsAt: z.ZodNullable<z.ZodISODateTime>;
+            upgradeCopy: z.ZodArray<z.ZodObject<{
+                tier: z.ZodEnum<{
+                    agency: "agency";
+                    free: "free";
+                    full: "full";
+                    lifetime: "lifetime";
+                    pro: "pro";
+                    search: "search";
+                }>;
+                gain: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strip>;
+    meta: z.ZodObject<{
+        readonly requestId: z.ZodString;
+        readonly version: z.ZodLiteral<"1.0">;
+        readonly total: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    data: z.ZodObject<{
+        readonly plan: z.ZodEnum<{
+            agency: "agency";
+            free: "free";
+            full: "full";
+            lifetime: "lifetime";
+            pro: "pro";
+            search: "search";
+        }>;
+        readonly meters: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodString;
+            group: z.ZodEnum<{
+                capacity: "capacity";
+                compute: "compute";
+                integrations: "integrations";
+            }>;
+            unit: z.ZodString;
+            used: z.ZodNumber;
+            limit: z.ZodNullable<z.ZodNumber>;
+            blocked: z.ZodBoolean;
+            overCap: z.ZodBoolean;
+            resetsAt: z.ZodNullable<z.ZodISODateTime>;
+            upgradeCopy: z.ZodArray<z.ZodObject<{
+                tier: z.ZodEnum<{
+                    agency: "agency";
+                    free: "free";
+                    full: "full";
+                    lifetime: "lifetime";
+                    pro: "pro";
+                    search: "search";
+                }>;
+                gain: z.ZodString;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
+    }, z.core.$strip>;
+    meta: z.ZodObject<{
+        readonly requestId: z.ZodString;
+        readonly version: z.ZodLiteral<"1.0">;
+        readonly total: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>>;
+export type AccountUsageQuery = z.input<typeof accountUsageQuerySchema>;
+export type AccountUsageData = z.output<typeof accountUsageDataSchema.producer>;
+export type UsageMeterProducer = z.output<typeof usageMeterProducerSchema>;
+export type UsageMeter = z.output<typeof usageMeterClientSchema>;
+export type AccountUsageResponse = z.output<typeof accountUsageResponseSchema.client>;
+export declare const accountUsageOperation: {
+    readonly id: 'account.usage';
+    readonly method: 'GET';
+    readonly path: '/api/v1/account/usage';
+    readonly visibility: 'public';
+    readonly semantics: {
+        readonly kind: 'query';
+        readonly sideEffects: 'none';
+        readonly retry: 'idempotent';
+        readonly readConsistency: 'primary';
+    };
+    readonly auth: {
+        readonly credentials: readonly ["session", "api_token"];
+        readonly scopes: readonly ["account:read"];
+        readonly minimumRole: 'viewer';
+        readonly ownership: 'team';
+    };
+    readonly request: {
+        readonly params: null;
+        readonly query: z.ZodObject<{
+            group: z.ZodOptional<z.ZodEnum<{
+                capacity: "capacity";
+                compute: "compute";
+                integrations: "integrations";
+            }>>;
+        }, z.core.$strict>;
+        readonly headers: null;
+        readonly body: null;
+    };
+    readonly responses: {
+        readonly 200: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+            data: z.ZodObject<{
+                readonly plan: z.ZodEnum<{
+                    agency: "agency";
+                    free: "free";
+                    full: "full";
+                    lifetime: "lifetime";
+                    pro: "pro";
+                    search: "search";
+                }>;
+                readonly meters: z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    label: z.ZodString;
+                    description: z.ZodString;
+                    group: z.ZodEnum<{
+                        capacity: "capacity";
+                        compute: "compute";
+                        integrations: "integrations";
+                    }>;
+                    unit: z.ZodString;
+                    used: z.ZodNumber;
+                    limit: z.ZodNullable<z.ZodNumber>;
+                    blocked: z.ZodBoolean;
+                    overCap: z.ZodBoolean;
+                    resetsAt: z.ZodNullable<z.ZodISODateTime>;
+                    upgradeCopy: z.ZodArray<z.ZodObject<{
+                        tier: z.ZodEnum<{
+                            agency: "agency";
+                            free: "free";
+                            full: "full";
+                            lifetime: "lifetime";
+                            pro: "pro";
+                            search: "search";
+                        }>;
+                        gain: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+                readonly requestId: z.ZodString;
+                readonly version: z.ZodLiteral<"1.0">;
+                readonly total: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodObject<{
+                readonly plan: z.ZodEnum<{
+                    agency: "agency";
+                    free: "free";
+                    full: "full";
+                    lifetime: "lifetime";
+                    pro: "pro";
+                    search: "search";
+                }>;
+                readonly meters: z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    label: z.ZodString;
+                    description: z.ZodString;
+                    group: z.ZodEnum<{
+                        capacity: "capacity";
+                        compute: "compute";
+                        integrations: "integrations";
+                    }>;
+                    unit: z.ZodString;
+                    used: z.ZodNumber;
+                    limit: z.ZodNullable<z.ZodNumber>;
+                    blocked: z.ZodBoolean;
+                    overCap: z.ZodBoolean;
+                    resetsAt: z.ZodNullable<z.ZodISODateTime>;
+                    upgradeCopy: z.ZodArray<z.ZodObject<{
+                        tier: z.ZodEnum<{
+                            agency: "agency";
+                            free: "free";
+                            full: "full";
+                            lifetime: "lifetime";
+                            pro: "pro";
+                            search: "search";
+                        }>;
+                        gain: z.ZodString;
+                    }, z.core.$loose>>;
+                }, z.core.$loose>>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+                readonly requestId: z.ZodString;
+                readonly version: z.ZodLiteral<"1.0">;
+                readonly total: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    };
+    readonly errors: readonly ["invalid_request", "unauthorized", "auth_expired", "forbidden", "rate_limited", "contract_violation", "internal_error"];
+    readonly errorResponse: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+        readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+                auth_expired: "auth_expired";
+                conflict: "conflict";
+                contract_violation: "contract_violation";
+                entitlement_required: "entitlement_required";
+                forbidden: "forbidden";
+                internal_error: "internal_error";
+                invalid_request: "invalid_request";
+                not_found: "not_found";
+                provider_unavailable: "provider_unavailable";
+                quota_exhausted: "quota_exhausted";
+                rate_limited: "rate_limited";
+                site_ambiguous: "site_ambiguous";
+                stale_evidence: "stale_evidence";
+                unauthorized: "unauthorized";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strict>;
+    }, z.core.$strip>, z.ZodObject<{
+        readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+                auth_expired: "auth_expired";
+                conflict: "conflict";
+                contract_violation: "contract_violation";
+                entitlement_required: "entitlement_required";
+                forbidden: "forbidden";
+                internal_error: "internal_error";
+                invalid_request: "invalid_request";
+                not_found: "not_found";
+                provider_unavailable: "provider_unavailable";
+                quota_exhausted: "quota_exhausted";
+                rate_limited: "rate_limited";
+                site_ambiguous: "site_ambiguous";
+                stale_evidence: "stale_evidence";
+                unauthorized: "unauthorized";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$loose>;
+    }, z.core.$strip>>;
+    readonly resources: {
+        readonly reads: readonly [{
+            readonly type: 'account.usage';
+            readonly idFrom: 'team.id';
+        }];
+        readonly changes: readonly [];
+    };
+    readonly policy: {
+        readonly rate: {
+            readonly name: 'public-v1-fixed-window';
+            readonly limit: 50;
+            readonly windowSeconds: 60;
+        };
+        readonly idempotency: {
+            readonly _tag: 'none';
+        };
+        readonly entitlement: null;
+        readonly meter: null;
+    };
+    readonly lifecycle: {
+        readonly introduced: '1.0.0';
+    };
+    readonly docs: {
+        readonly summary: 'Read account usage';
+        readonly description: 'Returns current Team-scoped public meter readings without spending quota.';
+        readonly tags: readonly ["Account"];
+        readonly examples: readonly [{
+            readonly request: {
+                readonly query: {};
+            };
+            readonly response: {
+                readonly status: 200;
+                readonly body: {
+                    readonly data: {
+                        readonly plan: 'pro';
+                        readonly meters: readonly [{
+                            readonly key: 'dataforseo';
+                            readonly label: 'Research lookups';
+                            readonly description: 'Third-party research requests used by live market analysis.';
+                            readonly group: 'integrations';
+                            readonly unit: 'requests';
+                            readonly used: 8;
+                            readonly limit: 100;
+                            readonly blocked: false;
+                            readonly overCap: false;
+                            readonly resetsAt: '2026-09-01T00:00:00.000Z';
+                            readonly upgradeCopy: readonly [{
+                                readonly tier: 'agency';
+                                readonly gain: 'Increase monthly research capacity.';
+                            }];
+                        }];
+                    };
+                    readonly meta: {
+                        readonly requestId: 'req_01JXYZ';
+                        readonly version: '1.0';
+                        readonly total: 1;
+                    };
+                };
+            };
+        }];
+    };
+};
+export declare const accountV1Registry: import("./core.js").PublicV1Registry<{
+    readonly usage: {
+        readonly id: 'account.usage';
+        readonly method: 'GET';
+        readonly path: '/api/v1/account/usage';
+        readonly visibility: 'public';
+        readonly semantics: {
+            readonly kind: 'query';
+            readonly sideEffects: 'none';
+            readonly retry: 'idempotent';
+            readonly readConsistency: 'primary';
+        };
+        readonly auth: {
+            readonly credentials: readonly ["session", "api_token"];
+            readonly scopes: readonly ["account:read"];
+            readonly minimumRole: 'viewer';
+            readonly ownership: 'team';
+        };
+        readonly request: {
+            readonly params: null;
+            readonly query: z.ZodObject<{
+                group: z.ZodOptional<z.ZodEnum<{
+                    capacity: "capacity";
+                    compute: "compute";
+                    integrations: "integrations";
+                }>>;
+            }, z.core.$strict>;
+            readonly headers: null;
+            readonly body: null;
+        };
+        readonly responses: {
+            readonly 200: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+                data: z.ZodObject<{
+                    readonly plan: z.ZodEnum<{
+                        agency: "agency";
+                        free: "free";
+                        full: "full";
+                        lifetime: "lifetime";
+                        pro: "pro";
+                        search: "search";
+                    }>;
+                    readonly meters: z.ZodArray<z.ZodObject<{
+                        key: z.ZodString;
+                        label: z.ZodString;
+                        description: z.ZodString;
+                        group: z.ZodEnum<{
+                            capacity: "capacity";
+                            compute: "compute";
+                            integrations: "integrations";
+                        }>;
+                        unit: z.ZodString;
+                        used: z.ZodNumber;
+                        limit: z.ZodNullable<z.ZodNumber>;
+                        blocked: z.ZodBoolean;
+                        overCap: z.ZodBoolean;
+                        resetsAt: z.ZodNullable<z.ZodISODateTime>;
+                        upgradeCopy: z.ZodArray<z.ZodObject<{
+                            tier: z.ZodEnum<{
+                                agency: "agency";
+                                free: "free";
+                                full: "full";
+                                lifetime: "lifetime";
+                                pro: "pro";
+                                search: "search";
+                            }>;
+                            gain: z.ZodString;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                }, z.core.$strip>;
+                meta: z.ZodObject<{
+                    readonly requestId: z.ZodString;
+                    readonly version: z.ZodLiteral<"1.0">;
+                    readonly total: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                data: z.ZodObject<{
+                    readonly plan: z.ZodEnum<{
+                        agency: "agency";
+                        free: "free";
+                        full: "full";
+                        lifetime: "lifetime";
+                        pro: "pro";
+                        search: "search";
+                    }>;
+                    readonly meters: z.ZodArray<z.ZodObject<{
+                        key: z.ZodString;
+                        label: z.ZodString;
+                        description: z.ZodString;
+                        group: z.ZodEnum<{
+                            capacity: "capacity";
+                            compute: "compute";
+                            integrations: "integrations";
+                        }>;
+                        unit: z.ZodString;
+                        used: z.ZodNumber;
+                        limit: z.ZodNullable<z.ZodNumber>;
+                        blocked: z.ZodBoolean;
+                        overCap: z.ZodBoolean;
+                        resetsAt: z.ZodNullable<z.ZodISODateTime>;
+                        upgradeCopy: z.ZodArray<z.ZodObject<{
+                            tier: z.ZodEnum<{
+                                agency: "agency";
+                                free: "free";
+                                full: "full";
+                                lifetime: "lifetime";
+                                pro: "pro";
+                                search: "search";
+                            }>;
+                            gain: z.ZodString;
+                        }, z.core.$loose>>;
+                    }, z.core.$loose>>;
+                }, z.core.$strip>;
+                meta: z.ZodObject<{
+                    readonly requestId: z.ZodString;
+                    readonly version: z.ZodLiteral<"1.0">;
+                    readonly total: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+        };
+        readonly errors: readonly ["invalid_request", "unauthorized", "auth_expired", "forbidden", "rate_limited", "contract_violation", "internal_error"];
+        readonly errorResponse: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+            readonly error: z.ZodObject<{
+                code: z.ZodEnum<{
+                    auth_expired: "auth_expired";
+                    conflict: "conflict";
+                    contract_violation: "contract_violation";
+                    entitlement_required: "entitlement_required";
+                    forbidden: "forbidden";
+                    internal_error: "internal_error";
+                    invalid_request: "invalid_request";
+                    not_found: "not_found";
+                    provider_unavailable: "provider_unavailable";
+                    quota_exhausted: "quota_exhausted";
+                    rate_limited: "rate_limited";
+                    site_ambiguous: "site_ambiguous";
+                    stale_evidence: "stale_evidence";
+                    unauthorized: "unauthorized";
+                }>;
+                message: z.ZodString;
+                requestId: z.ZodString;
+                retryable: z.ZodBoolean;
+                details: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strict>;
+        }, z.core.$strip>, z.ZodObject<{
+            readonly error: z.ZodObject<{
+                code: z.ZodEnum<{
+                    auth_expired: "auth_expired";
+                    conflict: "conflict";
+                    contract_violation: "contract_violation";
+                    entitlement_required: "entitlement_required";
+                    forbidden: "forbidden";
+                    internal_error: "internal_error";
+                    invalid_request: "invalid_request";
+                    not_found: "not_found";
+                    provider_unavailable: "provider_unavailable";
+                    quota_exhausted: "quota_exhausted";
+                    rate_limited: "rate_limited";
+                    site_ambiguous: "site_ambiguous";
+                    stale_evidence: "stale_evidence";
+                    unauthorized: "unauthorized";
+                }>;
+                message: z.ZodString;
+                requestId: z.ZodString;
+                retryable: z.ZodBoolean;
+                details: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$loose>;
+        }, z.core.$strip>>;
+        readonly resources: {
+            readonly reads: readonly [{
+                readonly type: 'account.usage';
+                readonly idFrom: 'team.id';
+            }];
+            readonly changes: readonly [];
+        };
+        readonly policy: {
+            readonly rate: {
+                readonly name: 'public-v1-fixed-window';
+                readonly limit: 50;
+                readonly windowSeconds: 60;
+            };
+            readonly idempotency: {
+                readonly _tag: 'none';
+            };
+            readonly entitlement: null;
+            readonly meter: null;
+        };
+        readonly lifecycle: {
+            readonly introduced: '1.0.0';
+        };
+        readonly docs: {
+            readonly summary: 'Read account usage';
+            readonly description: 'Returns current Team-scoped public meter readings without spending quota.';
+            readonly tags: readonly ["Account"];
+            readonly examples: readonly [{
+                readonly request: {
+                    readonly query: {};
+                };
+                readonly response: {
+                    readonly status: 200;
+                    readonly body: {
+                        readonly data: {
+                            readonly plan: 'pro';
+                            readonly meters: readonly [{
+                                readonly key: 'dataforseo';
+                                readonly label: 'Research lookups';
+                                readonly description: 'Third-party research requests used by live market analysis.';
+                                readonly group: 'integrations';
+                                readonly unit: 'requests';
+                                readonly used: 8;
+                                readonly limit: 100;
+                                readonly blocked: false;
+                                readonly overCap: false;
+                                readonly resetsAt: '2026-09-01T00:00:00.000Z';
+                                readonly upgradeCopy: readonly [{
+                                    readonly tier: 'agency';
+                                    readonly gain: 'Increase monthly research capacity.';
+                                }];
+                            }];
+                        };
+                        readonly meta: {
+                            readonly requestId: 'req_01JXYZ';
+                            readonly version: '1.0';
+                            readonly total: 1;
+                        };
+                    };
+                };
+            }];
+        };
+    };
+}>;