@story-protocol/ipkit 0.4.0-beta.10

package/dist/types/schema.d.ts

@@ -0,0 +1,1168 @@
+export interface paths {
+    "/assets": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * List IP Assets
+         * @description Retrieve a list of IP assets with pagination and filtering options. The 'where' field is optional and should only be provided when filtering by specific IP IDs, owner address, or token contract address. This endpoint can also be used to fetch a single asset by passing its ID in the ipIds filter.
+         */
+        post: operations["listIPAssetsV4"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/assets/edges": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * List IP Asset Edges
+         * @description Retrieve a list of edges (derivative registered events) that represent relationships between IP assets. These edges show parent-child relationships formed through licensing.
+         */
+        post: operations["listEdgesV4"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/collections": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * List Collections
+         * @description Retrieve a list of collections with pagination and filtering options. Collections are ordered by most recent or least recent updated time only. Collections are automatically enriched with metadata. The 'where' field is optional and should only be provided when filtering by specific collection addresses or asset counts. This endpoint can also be used to fetch a single collection by passing its address in the collectionAddresses filter. Collections that don't exist in Alchemy or encounter errors will return with empty metadata instead of failing the entire request.
+         */
+        post: operations["listCollectionsV4"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/disputes": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * List Disputes
+         * @description Retrieve a paginated, filtered list of disputes from the SOS database.
+         *     This endpoint supports various filtering options including:
+         *     - Filter by dispute ID, target IP ID, initiator address, or status
+         *     - Filter by block number ranges (blockNumber, blockNumberLte, blockNumberGte)
+         *     - Sort by block number, dispute timestamp, or ID
+         *     - Pagination with configurable limit and offset
+         *
+         *     Key v4 Enhancements:
+         *     - Flattened request structure: Query parameters are directly in the request body, not nested in an "options" object
+         *     - Offset-based pagination: Unlike v3, this endpoint supports both limit and offset parameters for flexible pagination
+         *     - Block number range filtering: Added blockNumberGte for greater-than-or-equal filtering (complements existing blockNumberLte)
+         *     - Pagination metadata in response: Returns total count and hasMore flag
+         *
+         *     The response format is aligned with v3 for compatibility, using big integers for numeric fields and hex strings for data fields.
+         */
+        post: operations["listDisputesV4"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/disputes/{disputeId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get a Dispute
+         * @description Retrieve a single dispute by its ID from the SOS database. This endpoint provides detailed information about a specific dispute including its status, involved parties, and related metadata.
+         */
+        get: operations["getDisputeV4"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/licenses/tokens": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Get License Tokens
+         * @description Retrieve license tokens with optional filtering. If no filters are provided, returns all license tokens. Supports filtering by owner wallet address and/or licensor IP ID. Results are paginated and can be ordered by 'blockNumber' (default: descending).
+         */
+        post: operations["getLicenseTokensV4"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/search": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Search IP Assets
+         * @description Perform vector search for IP assets based on query text and optional media type filter. This endpoint uses AI-powered search to find relevant assets by semantic similarity.
+         */
+        post: operations["searchV4"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/transactions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * List IP Transactions
+         * @description Retrieve a list of IP transactions with pagination and filtering options. The 'where' field is optional and should only be provided when filtering by specific transaction hashes, event types, or block ranges. This endpoint can also be used to fetch specific transactions by passing their hashes in the txHashes filter.
+         */
+        post: operations["listTransactionsV4"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        CollectionsRequestBodyHuma: {
+            /**
+             * Format: uri
+             * @description A URL to the JSON Schema for this object.
+             */
+            readonly $schema?: string;
+            /**
+             * @description Field to order results by (only updatedAt is supported)
+             * @default updatedAt
+             * @enum {string}
+             */
+            orderBy: "updatedAt";
+            /**
+             * @description Order direction: asc for least recent, desc for most recent
+             * @default desc
+             * @enum {string}
+             */
+            orderDirection: "asc" | "desc";
+            /** @description Pagination configuration */
+            pagination?: components["schemas"]["PaginationOptionsHuma"];
+            /** @description Optional filter options for collections */
+            where?: components["schemas"]["CollectionsWhereOptionsHuma"];
+        };
+        CollectionsResponseBodyHuma: {
+            /**
+             * Format: uri
+             * @description A URL to the JSON Schema for this object.
+             */
+            readonly $schema?: string;
+            /** @description List of enriched collections */
+            data: components["schemas"]["EnrichedCollection"][] | null;
+            /** @description Pagination metadata */
+            pagination?: components["schemas"]["PaginationMetadataHuma"];
+        };
+        CollectionsWhereOptionsHuma: {
+            /** @description List of collection addresses to filter by (max 200) */
+            collectionAddresses?: string[] | null;
+            /**
+             * Format: int64
+             * @description Maximum asset count threshold
+             */
+            maxAssetCount?: number;
+            /**
+             * Format: int64
+             * @description Minimum asset count threshold
+             */
+            minAssetCount?: number;
+        };
+        ContractMetadata: {
+            address: string;
+            chain: string;
+            contractDeployer: string;
+            /** Format: int64 */
+            deployedBlockNumber: number;
+            name: string;
+            openSeaMetadata: components["schemas"]["ContractMetadataOpenSeaMetadataStruct"];
+            symbol: string;
+            tokenType: string;
+            totalSupply: string;
+        };
+        ContractMetadataByAddressResponse: {
+            address: string;
+            chain: string;
+            contractDeployer: string;
+            /** Format: int64 */
+            deployedBlockNumber: number;
+            name: string;
+            openSeaMetadata: components["schemas"]["ContractMetadataByAddressResponseOpenSeaMetadataStruct"];
+            symbol: string;
+            tokenType: string;
+            totalSupply: string;
+        };
+        ContractMetadataByAddressResponseOpenSeaMetadataStruct: {
+            bannerImageUrl: string;
+            collectionName: string;
+            collectionSlug: string;
+            description: string;
+            discordUrl: string;
+            externalUrl: string | null;
+            /** Format: double */
+            floorPrice: number;
+            imageUrl: string;
+            /** Format: date-time */
+            lastIngestedAt: string;
+            safelistRequestStatus: string;
+            twitterUsername: string;
+        };
+        ContractMetadataOpenSeaMetadataStruct: {
+            bannerImageUrl: string;
+            collectionName: string;
+            collectionSlug: string;
+            description: string;
+            discordUrl: string;
+            externalUrl: string | null;
+            /** Format: double */
+            floorPrice: number;
+            imageUrl: string;
+            /** Format: date-time */
+            lastIngestedAt: string;
+            safelistRequestStatus: string;
+            twitterUsername: string;
+        };
+        DerivativeRegisteredEvent: {
+            /** Format: int64 */
+            blockNumber: number;
+            /** Format: date-time */
+            blockTimestamp: string;
+            caller: string;
+            childIpId: string;
+            /** Format: int64 */
+            id: number;
+            licenseTemplate: string;
+            licenseTermsId: string;
+            licenseTokenId: string;
+            /** Format: int64 */
+            logIndex: number;
+            parentIpId: string;
+            /** Format: date-time */
+            processedAt: string;
+            txHash: string;
+        };
+        Dispute: {
+            arbitrationPolicy: string;
+            blockNumber: string | null;
+            blockTimestamp?: string;
+            counterEvidenceHash: string;
+            currentTag: string;
+            data: string;
+            deletedAt?: string;
+            disputeTimestamp: string | null;
+            evidenceHash: string;
+            id: string | null;
+            initiator: string;
+            liveness: string | null;
+            logIndex?: string;
+            status: string;
+            targetIpId: string;
+            targetTag: string;
+            transactionHash: string;
+            umaLink?: string;
+        };
+        DisputePaginationHuma: {
+            /**
+             * Format: int64
+             * @description Number of items to return (max: 200)
+             * @default 100
+             */
+            limit: number;
+            /**
+             * Format: int64
+             * @description Number of items to skip for pagination (v4 enhancement)
+             * @default 0
+             */
+            offset: number;
+        };
+        DisputePaginationMetadataHuma: {
+            /** @description Whether there are more disputes */
+            hasMore: boolean;
+            /**
+             * Format: int64
+             * @description Current limit
+             */
+            limit: number;
+            /**
+             * Format: int64
+             * @description Current offset
+             */
+            offset: number;
+            /**
+             * Format: int64
+             * @description Total count of disputes
+             */
+            total?: number;
+        };
+        DisputeWhereHuma: {
+            /** @description Filter by exact block number */
+            blockNumber?: string;
+            /** @description Filter by block number >= this value (v4 enhancement) */
+            blockNumberGte?: string;
+            /** @description Filter by block number <= this value */
+            blockNumberLte?: string;
+            /** @description Dispute ID to filter by */
+            id?: string;
+            /** @description Initiator wallet address to filter by */
+            initiator?: string;
+            /** @description Target IP ID to filter by */
+            targetIpId?: string;
+        };
+        DisputesRequestBodyHuma: {
+            /**
+             * Format: uri
+             * @description A URL to the JSON Schema for this object.
+             */
+            readonly $schema?: string;
+            /** @description Field to order results by (must be blockNumber or empty) */
+            orderBy?: string;
+            /** @description Order direction for results (asc or desc) */
+            orderDirection?: string;
+            /** @description Pagination configuration */
+            pagination?: components["schemas"]["DisputePaginationHuma"];
+            /** @description Filter options for disputes */
+            where?: components["schemas"]["DisputeWhereHuma"];
+        };
+        EdgesRequestBodyHuma: {
+            /**
+             * Format: uri
+             * @description A URL to the JSON Schema for this object.
+             */
+            readonly $schema?: string;
+            /**
+             * @description Field to order results by (currently only blockNumber is supported)
+             * @enum {string}
+             */
+            orderBy?: "blockNumber";
+            /**
+             * @description Order direction for results
+             * @default desc
+             * @enum {string}
+             */
+            orderDirection: "asc" | "desc";
+            /** @description Pagination configuration */
+            pagination?: components["schemas"]["PaginationOptionsHuma"];
+            /** @description Filter options for edges */
+            where?: components["schemas"]["EdgesWhereOptionsHuma"];
+        };
+        EdgesResponseHumaBody: {
+            /**
+             * Format: uri
+             * @description A URL to the JSON Schema for this object.
+             */
+            readonly $schema?: string;
+            /** @description List of derivative registered events (edges) */
+            data: components["schemas"]["DerivativeRegisteredEvent"][] | null;
+            /** @description Pagination metadata */
+            pagination?: components["schemas"]["PaginationMetadataHuma"];
+        };
+        EdgesWhereOptionsHuma: {
+            /**
+             * Format: int64
+             * @description Block number to filter by
+             */
+            blockNumber?: number;
+            /** @description Child IP ID to filter by */
+            childIpId?: string;
+            /** @description Parent IP ID to filter by */
+            parentIpId?: string;
+            /** @description Transaction hash to filter by */
+            txHash?: string;
+        };
+        EnrichedCollection: {
+            /** Format: int64 */
+            assetCount: number;
+            /** Format: int64 */
+            cancelledDisputeCount: number;
+            collectionAddress: string;
+            collectionMetadata?: components["schemas"]["ContractMetadataByAddressResponse"];
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: int64 */
+            judgedDisputeCount: number;
+            /** Format: int64 */
+            licensesCount: number;
+            /** Format: int64 */
+            raisedDisputeCount: number;
+            /** Format: int64 */
+            resolvedDisputeCount: number;
+            /** Format: date-time */
+            updatedAt: string;
+        };
+        EnrichedIPAsset: {
+            /** Format: int64 */
+            ancestorsCount: number;
+            /** Format: int64 */
+            blockNumber: number;
+            chainId: string;
+            /** Format: int64 */
+            childrenCount: number;
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: int64 */
+            descendantsCount: number;
+            description: string;
+            infringementStatus?: components["schemas"]["InfringementStatus"][] | null;
+            ipId: string;
+            ipaMetadataUri?: string;
+            isInGroup: boolean;
+            /** Format: date-time */
+            lastUpdatedAt: string;
+            licenses?: components["schemas"]["License"][] | null;
+            /** Format: int64 */
+            logIndex: number;
+            moderationStatus?: components["schemas"]["ModerationStatus"];
+            name: string;
+            nftMetadata?: components["schemas"]["NFTMetadata"];
+            ownerAddress: string;
+            /** Format: int64 */
+            parentsCount: number;
+            registrationDate: string;
+            rootIPs: string[] | null;
+            title: string;
+            tokenContract: string;
+            tokenId: string;
+            txHash: string;
+            uri: string;
+        };
+        ErrorDetail: {
+            /** @description Where the error occurred, e.g. 'body.items[3].tags' or 'path.thing-id' */
+            location?: string;
+            /** @description Error message text */
+            message?: string;
+            /** @description The value at the given location */
+            value?: unknown;
+        };
+        ErrorModel: {
+            /**
+             * Format: uri
+             * @description A URL to the JSON Schema for this object.
+             */
+            readonly $schema?: string;
+            /** @description A human-readable explanation specific to this occurrence of the problem. */
+            detail?: string;
+            /** @description Optional list of individual error details */
+            errors?: components["schemas"]["ErrorDetail"][] | null;
+            /**
+             * Format: uri
+             * @description A URI reference that identifies the specific occurrence of the problem.
+             */
+            instance?: string;
+            /**
+             * Format: int64
+             * @description HTTP status code
+             */
+            status?: number;
+            /** @description A short, human-readable summary of the problem type. This value should not change between occurrences of the error. */
+            title?: string;
+            /**
+             * Format: uri
+             * @description A URI reference to human-readable documentation for the error.
+             * @default about:blank
+             */
+            type: string;
+        };
+        GetDisputeResponseHumaBody: {
+            /**
+             * Format: uri
+             * @description A URL to the JSON Schema for this object.
+             */
+            readonly $schema?: string;
+            /** @description Dispute information */
+            data: components["schemas"]["Dispute"];
+        };
+        IPAssetsRequestBodyHuma: {
+            /**
+             * Format: uri
+             * @description A URL to the JSON Schema for this object.
+             */
+            readonly $schema?: string;
+            /** @description Include license information in response */
+            includeLicenses?: boolean;
+            /** @description Filter for moderated content only */
+            moderated?: boolean;
+            /**
+             * @description Field to order results by
+             * @default blockNumber
+             * @enum {string}
+             */
+            orderBy: "descendantCount" | "blockNumber" | "createdAt";
+            /**
+             * @description Order direction for results
+             * @default desc
+             * @enum {string}
+             */
+            orderDirection: "asc" | "desc";
+            /** @description Pagination configuration */
+            pagination?: components["schemas"]["PaginationOptionsHuma"];
+            /** @description Optional filter options for IP assets */
+            where?: components["schemas"]["IPAssetsWhereOptionsHuma"];
+        };
+        IPAssetsResponseHumaBody: {
+            /**
+             * Format: uri
+             * @description A URL to the JSON Schema for this object.
+             */
+            readonly $schema?: string;
+            /** @description List of enriched IP assets */
+            data: components["schemas"]["EnrichedIPAsset"][] | null;
+            /** @description Pagination metadata */
+            pagination?: components["schemas"]["PaginationMetadataHuma"];
+        };
+        IPAssetsWhereOptionsHuma: {
+            /** @description List of IP asset IDs to filter by (max 200) */
+            ipIds?: string[] | null;
+            /** @description Owner wallet address to filter by */
+            ownerAddress?: string;
+            /** @description Token contract address to filter by */
+            tokenContract?: string;
+        };
+        IPSearchResult: {
+            description: string;
+            ipId: string;
+            mediaType: string;
+            /** Format: double */
+            score: number;
+            /** Format: double */
+            similarity: number;
+            title: string;
+        };
+        IPTransaction: {
+            /** Format: int64 */
+            blockNumber: number;
+            /** Format: date-time */
+            createdAt: string;
+            eventType: string;
+            /** Format: int64 */
+            id: number;
+            initiator: string;
+            ipId: string;
+            /** Format: int64 */
+            logIndex: number;
+            txHash: string;
+        };
+        InfringementStatus: {
+            /** Format: date-time */
+            createdAt: string;
+            customData: string;
+            infringementDetails: string;
+            isInfringing: boolean;
+            providerName: string;
+            providerURL: string;
+            /** Format: date-time */
+            responseTime: string;
+            status: string;
+            /** Format: date-time */
+            updatedAt: string;
+        };
+        License: {
+            /** Format: date-time */
+            createdAt: string;
+            licenseTemplateId: string;
+            licenseTermsId: string;
+            licensingConfig: components["schemas"]["LicensingConfig"];
+            templateMetadataUri: string;
+            templateName: string;
+            terms: components["schemas"]["LicenseTerms"];
+            /** Format: date-time */
+            updatedAt: string;
+        };
+        LicenseTerms: {
+            commercialAttribution: boolean;
+            commercialRevCeiling: string;
+            /** Format: int64 */
+            commercialRevShare: number;
+            commercialUse: boolean;
+            commercializerChecker: string;
+            commercializerCheckerData: string;
+            currency: string;
+            defaultMintingFee: string;
+            derivativeRevCeiling: string;
+            derivativesAllowed: boolean;
+            derivativesApproval: boolean;
+            derivativesAttribution: boolean;
+            derivativesReciprocal: boolean;
+            expiration: string;
+            royaltyPolicy: string;
+            transferable: boolean;
+            uri: string;
+        };
+        LicenseToken: {
+            blockNumber: string;
+            blockTime: string;
+            burntAt: string;
+            id: string;
+            licenseTemplate: string;
+            licenseTermsId: string;
+            licensorIpId: string;
+            owner: string;
+            transferable: string;
+        };
+        LicenseTokensRequestBodyHuma: {
+            /**
+             * Format: uri
+             * @description A URL to the JSON Schema for this object.
+             */
+            readonly $schema?: string;
+            /**
+             * @description Field to order results by (only 'blockNumber' is supported)
+             * @default blockNumber
+             * @enum {string}
+             */
+            orderBy: "blockNumber";
+            /**
+             * @description Order direction for results ('asc' for ascending, 'desc' for descending)
+             * @default desc
+             * @enum {string}
+             */
+            orderDirection: "asc" | "desc";
+            /** @description Pagination configuration (optional, defaults: limit=100, offset=0) */
+            pagination?: components["schemas"]["PaginationOptionsHuma"];
+            /** @description Optional filter options for license tokens */
+            where?: components["schemas"]["LicenseTokensWhereOptionsHuma"];
+        };
+        LicenseTokensResponseHumaBody: {
+            /**
+             * Format: uri
+             * @description A URL to the JSON Schema for this object.
+             */
+            readonly $schema?: string;
+            /** @description List of license tokens matching the filter criteria */
+            data: components["schemas"]["LicenseToken"][] | null;
+            /** @description Pagination metadata including total count and hasMore flag */
+            pagination?: components["schemas"]["PaginationMetadataHuma"];
+        };
+        LicenseTokensWhereOptionsHuma: {
+            /** @description Optional licensor IP ID to filter license tokens */
+            licensorIpId?: string;
+            /** @description Optional owner wallet address to filter license tokens */
+            ownerAddress?: string;
+        };
+        LicensingConfig: {
+            /** Format: int64 */
+            commercialRevShare: number;
+            disabled: boolean;
+            expectGroupRewardPool: string;
+            /** Format: int64 */
+            expectMinimumGroupRewardShare: number;
+            hookData: string;
+            isSet: boolean;
+            licensingHook: string;
+            mintingFee: string;
+        };
+        ListDisputesResponseHumaBody: {
+            /**
+             * Format: uri
+             * @description A URL to the JSON Schema for this object.
+             */
+            readonly $schema?: string;
+            /** @description List of disputes */
+            data: components["schemas"]["Dispute"][] | null;
+            /** @description Pagination metadata (v4 enhancement, not in v3) */
+            pagination?: components["schemas"]["DisputePaginationMetadataHuma"];
+        };
+        ModerationStatus: {
+            adult: string;
+            medical: string;
+            racy: string;
+            spoof: string;
+            violence: string;
+        };
+        NFTMetadata: {
+            animation: components["schemas"]["NFTMetadataAnimationStruct"];
+            collection: components["schemas"]["NFTMetadataCollectionStruct"];
+            contract: components["schemas"]["ContractMetadata"];
+            contract_address: string;
+            description: string | null;
+            image: components["schemas"]["NFTMetadataImageStruct"];
+            mint: components["schemas"]["NFTMetadataMintStruct"];
+            name: string;
+            nft_id: string;
+            raw: unknown;
+            /** Format: date-time */
+            timeLastUpdated: string;
+            tokenId: string;
+            tokenType: string;
+            tokenUri: string;
+        };
+        NFTMetadataAnimationStruct: {
+            cachedUrl: string;
+            contentType: string;
+            originalUrl: string;
+            /** Format: int64 */
+            size: number;
+        };
+        NFTMetadataCollectionStruct: {
+            bannerImageUrl: string;
+            externalUrl: string | null;
+            name: string;
+            slug: string;
+        };
+        NFTMetadataImageStruct: {
+            cachedUrl: string;
+            contentType: string;
+            originalUrl: string;
+            pngUrl: string;
+            /** Format: int64 */
+            size: number;
+            thumbnailUrl: string;
+        };
+        NFTMetadataMintStruct: {
+            /** Format: int64 */
+            blockNumber: number | null;
+            mintAddress: string | null;
+            timestamp: string | null;
+            transactionHash: string | null;
+        };
+        PaginationMetadataHuma: {
+            /** @description Whether there are more items */
+            hasMore: boolean;
+            /**
+             * Format: int64
+             * @description Current limit
+             */
+            limit: number;
+            /**
+             * Format: int64
+             * @description Current offset
+             */
+            offset: number;
+            /**
+             * Format: int64
+             * @description Total count of items
+             */
+            total: number;
+        };
+        PaginationOptionsHuma: {
+            /**
+             * Format: int64
+             * @description Number of items to return
+             * @default 20
+             */
+            limit: number;
+            /**
+             * Format: int64
+             * @description Number of items to skip
+             * @default 0
+             */
+            offset: number;
+        };
+        SearchRequestBodyHuma: {
+            /**
+             * Format: uri
+             * @description A URL to the JSON Schema for this object.
+             */
+            readonly $schema?: string;
+            /**
+             * @description Optional media type filter - must be 'audio', 'video', or 'image'. Leave empty to search all media types
+             * @enum {string}
+             */
+            mediaType?: "audio" | "video" | "image";
+            /** @description Pagination configuration */
+            pagination?: components["schemas"]["PaginationOptionsHuma"];
+            /** @description The search query string */
+            query: string;
+        };
+        SearchResponseBodyHuma: {
+            /**
+             * Format: uri
+             * @description A URL to the JSON Schema for this object.
+             */
+            readonly $schema?: string;
+            /** @description List of IP asset search results */
+            data: components["schemas"]["IPSearchResult"][] | null;
+            /** @description Pagination information */
+            pagination?: components["schemas"]["PaginationMetadataHuma"];
+            /**
+             * Format: int64
+             * @description Total number of search results found
+             */
+            total: number;
+        };
+        TransactionsRequestBodyHuma: {
+            /**
+             * Format: uri
+             * @description A URL to the JSON Schema for this object.
+             */
+            readonly $schema?: string;
+            /**
+             * @description Field to order results by
+             * @default blockNumber
+             * @enum {string}
+             */
+            orderBy: "blockNumber" | "createdAt" | "eventType" | "txHash" | "ipId" | "initiator";
+            /**
+             * @description Order direction for results
+             * @default desc
+             * @enum {string}
+             */
+            orderDirection: "asc" | "desc";
+            /** @description Pagination configuration */
+            pagination?: components["schemas"]["PaginationOptionsHuma"];
+            /** @description Optional filter options for transactions */
+            where?: components["schemas"]["TransactionsWhereOptionsHuma"];
+        };
+        TransactionsResponseBodyHuma: {
+            /**
+             * Format: uri
+             * @description A URL to the JSON Schema for this object.
+             */
+            readonly $schema?: string;
+            /** @description List of IP transactions */
+            data: components["schemas"]["IPTransaction"][] | null;
+            /** @description Pagination information */
+            pagination?: components["schemas"]["PaginationMetadataHuma"];
+        };
+        TransactionsWhereOptionsHuma: {
+            /**
+             * Format: int64
+             * @description Filter transactions from this block number (inclusive)
+             */
+            blockGte?: number;
+            /**
+             * Format: int64
+             * @description Filter transactions up to this block number (inclusive)
+             */
+            blockLte?: number;
+            /** @description List of event types to filter by (max 50) */
+            eventTypes?: string[] | null;
+            /** @description List of initiator addresses to filter by (max 200) */
+            initiators?: string[] | null;
+            /** @description List of IP asset IDs to filter by (max 200) */
+            ipIds?: string[] | null;
+            /** @description List of transaction hashes to filter by (max 200) */
+            txHashes?: string[] | null;
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export interface operations {
+    listIPAssetsV4: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["IPAssetsRequestBodyHuma"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["IPAssetsResponseHumaBody"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorModel"];
+                };
+            };
+        };
+    };
+    listEdgesV4: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["EdgesRequestBodyHuma"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["EdgesResponseHumaBody"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorModel"];
+                };
+            };
+        };
+    };
+    listCollectionsV4: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CollectionsRequestBodyHuma"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CollectionsResponseBodyHuma"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorModel"];
+                };
+            };
+        };
+    };
+    listDisputesV4: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["DisputesRequestBodyHuma"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ListDisputesResponseHumaBody"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorModel"];
+                };
+            };
+        };
+    };
+    getDisputeV4: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description Dispute ID to retrieve
+                 * @example 123
+                 */
+                disputeId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GetDisputeResponseHumaBody"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorModel"];
+                };
+            };
+        };
+    };
+    getLicenseTokensV4: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["LicenseTokensRequestBodyHuma"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LicenseTokensResponseHumaBody"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorModel"];
+                };
+            };
+        };
+    };
+    searchV4: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SearchRequestBodyHuma"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SearchResponseBodyHuma"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorModel"];
+                };
+            };
+        };
+    };
+    listTransactionsV4: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["TransactionsRequestBodyHuma"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TransactionsResponseBodyHuma"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorModel"];
+                };
+            };
+        };
+    };
+}
+//# sourceMappingURL=schema.d.ts.map