@carrot-foundation/schemas 0.1.20 → 0.1.21

package/dist/shared/definitions.schema.js

@@ -1,283 +0,0 @@
-import { z } from 'zod';
-export const UuidSchema = z.uuidv4('Must be a valid UUID v4 string').meta({
-    title: 'UUID',
-    description: 'A universally unique identifier version 4',
-    examples: [
-        'ad44dd3f-f176-4b98-bf78-5ee6e77d0530',
-        '6f520d88-864d-432d-bf9f-5c3166c4818f',
-        'f77afa89-1c58-40fd-9bf5-8a86703a8af4',
-    ],
-});
-export const EthereumAddressSchema = z
-    .string()
-    .regex(/^0x[a-fA-F0-9]{40}$/, 'Must be a valid Ethereum address in lowercase hexadecimal format')
-    .meta({
-    title: 'Ethereum Address',
-    description: 'A valid Ethereum address in hexadecimal format',
-    examples: [
-        '0x1234567890abcdef1234567890abcdef12345678',
-        '0xabcdef1234567890abcdef1234567890abcdef12',
-    ],
-});
-export const IsoTimestampSchema = z.iso
-    .datetime({
-    message: 'Must be a valid ISO 8601 timestamp with timezone',
-})
-    .meta({
-    title: 'ISO Timestamp',
-    description: 'ISO 8601 formatted timestamp with timezone information',
-    examples: ['2024-12-05T11:02:47.000Z', '2025-02-22T10:35:12.000Z'],
-});
-export const IsoDateSchema = z.iso
-    .date('Must be a valid ISO 8601 date (YYYY-MM-DD)')
-    .meta({
-    title: 'ISO Date',
-    description: 'ISO 8601 formatted date in YYYY-MM-DD format',
-    examples: ['2024-12-05', '2025-02-22', '2024-02-10'],
-});
-export const IsoCountryCodeSchema = z
-    .string()
-    .regex(/^[A-Z]{2}$/, 'Must be a valid ISO 3166-1 alpha-2 country code')
-    .meta({
-    title: 'ISO Country Code',
-    description: 'Two-letter country code following ISO 3166-1 alpha-2 standard',
-    examples: ['BR', 'US', 'DE'],
-});
-export const IsoAdministrativeDivisionCodeSchema = z
-    .string()
-    .regex(/^[A-Z]{2}-[A-Z0-9]{1,3}$/, 'Must be a valid ISO 3166-2 administrative division code')
-    .meta({
-    title: 'ISO Administrative Division Code',
-    description: 'Administrative division code following ISO 3166-2 standard',
-    examples: ['BR-AP', 'BR-ES', 'US-CA'],
-});
-export const LatitudeSchema = z
-    .number()
-    .min(-90)
-    .max(90)
-    .meta({
-    title: 'Latitude',
-    description: 'Geographic latitude coordinate in decimal degrees',
-    examples: [-0.02, -20.38, 40.7128],
-});
-export const LongitudeSchema = z
-    .number()
-    .min(-180)
-    .max(180)
-    .meta({
-    title: 'Longitude',
-    description: 'Geographic longitude coordinate in decimal degrees',
-    examples: [-51.06, -40.34, -74.006],
-});
-export const WeightKgSchema = z
-    .number()
-    .min(0)
-    .meta({
-    title: 'Weight (kg)',
-    description: 'Weight measurement in kilograms',
-    examples: [3000, 1500, 500],
-});
-export const NonEmptyStringSchema = z
-    .string()
-    .min(1, 'Cannot be empty')
-    .meta({
-    title: 'Non-Empty String',
-    description: 'A string that contains at least one character',
-    examples: ['Example text', 'Sample value', 'Test string'],
-});
-export const SlugSchema = NonEmptyStringSchema.regex(/^[a-z0-9-]+$/, 'Must contain only lowercase letters, numbers, and hyphens')
-    .max(100)
-    .meta({
-    title: 'Slug',
-    description: 'URL-friendly identifier with lowercase letters, numbers, and hyphens',
-    examples: ['mass-id-123', 'recycled-plastic', 'organic-waste'],
-});
-export const WasteTypeSchema = NonEmptyStringSchema.meta({
-    title: 'Waste Type',
-    description: 'Category or type of waste material',
-    examples: ['Organic', 'Plastic', 'Metal'],
-});
-export const WasteSubtypeSchema = NonEmptyStringSchema.max(100).meta({
-    title: 'Waste Subtype',
-    description: 'Specific subcategory of waste within a waste type',
-    examples: ['Food, Food Waste and Beverages', 'PET Bottles', 'Aluminum Cans'],
-});
-export const ParticipantRoleSchema = NonEmptyStringSchema.max(100).meta({
-    title: 'Participant Role',
-    description: 'Role that a participant plays in the waste management supply chain',
-    examples: ['Waste Generator', 'Hauler', 'Recycler'],
-});
-export const ParticipantNameSchema = NonEmptyStringSchema.max(100).meta({
-    title: 'Participant Name',
-    description: 'Name of a participant in the waste management system',
-    examples: ['Enlatados Produção', 'Eco Reciclagem', 'Green Tech Corp'],
-});
-export const FacilityTypeSchema = z
-    .enum([
-    'Waste Generation',
-    'Collection Point',
-    'Transfer Station',
-    'Sorting Facility',
-    'Composting Facility',
-    'Recycling Facility',
-    'Processing Facility',
-    'Disposal Facility',
-    'Administrative Office',
-])
-    .meta({
-    title: 'Facility Type',
-    description: 'Type of facility in the waste management infrastructure',
-    examples: ['Waste Generation', 'Recycling Facility', 'Collection Point'],
-});
-export const BlockchainChainIdSchema = z
-    .number()
-    .int()
-    .min(1)
-    .meta({
-    title: 'Chain ID',
-    description: 'Blockchain network identifier',
-    examples: [1, 137, 11155111],
-});
-export const PercentageSchema = z
-    .number()
-    .min(0)
-    .max(100)
-    .meta({
-    title: 'Percentage',
-    description: 'Percentage value between 0 and 100',
-    examples: [50, 75.5, 100],
-});
-export const NonNegativeIntegerSchema = z
-    .number()
-    .int()
-    .min(0)
-    .meta({
-    title: 'Non-Negative Integer',
-    description: 'Integer value that is zero or positive',
-    examples: [0, 123, 4126],
-});
-export const PositiveIntegerSchema = z
-    .number()
-    .int()
-    .min(1)
-    .meta({
-    title: 'Positive Integer',
-    description: 'Integer value that is greater than zero',
-    examples: [1, 123, 456],
-});
-export const NonNegativeFloatSchema = z
-    .number()
-    .min(0)
-    .meta({
-    title: 'Non-Negative Float',
-    description: 'Floating-point number that is zero or positive',
-    examples: [0.0, 45.2, 72.5],
-});
-export const HoursSchema = z
-    .number()
-    .min(0)
-    .multipleOf(0.1)
-    .meta({
-    title: 'Hours',
-    description: 'Time duration in hours with 0.1 hour precision',
-    examples: [72.5, 24.0, 168.5],
-});
-export const IpfsUriSchema = NonEmptyStringSchema.regex(/^ipfs:\/\/[a-zA-Z0-9]+(\/.*)?$/, 'Must be a valid IPFS URI with CID').meta({
-    title: 'IPFS URI',
-    description: 'InterPlanetary File System URI pointing to distributed content',
-    examples: [
-        'ipfs://QmTy8w65yBXgyfG2ZBg5TrfB2hPjrDQH3RCQFJGkARStJb/mass-id-organic.png',
-        'ipfs://QmYjtig7VJQ6XsnUjqqJvj7QaMcCAwtrgNdahSiFofrE7o',
-    ],
-});
-export const SemanticVersionSchema = NonEmptyStringSchema.regex(/^v?\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?(\+[a-zA-Z0-9.-]+)?$/, 'Must be a valid semantic version string').meta({
-    title: 'Semantic Version',
-    description: 'Version string following semantic versioning specification',
-    examples: ['0.1.0', '1.0.0', '2.1.3'],
-});
-export const TokenIdSchema = NonEmptyStringSchema.regex(/^\d+$/, 'Must be a numeric string (supports uint256)').meta({
-    title: 'Token ID',
-    description: 'Numeric identifier for blockchain tokens as string',
-    examples: ['123', '456789', '1000000'],
-});
-export const HexColorSchema = NonEmptyStringSchema.regex(/^#[0-9A-F]{6}$/, 'Must be a hex color code with # prefix and uppercase').meta({
-    title: 'Hex Color',
-    description: 'Hexadecimal color code with hash prefix',
-    examples: ['#2D5A27', '#FF5733', '#1E90FF'],
-});
-export const Sha256HashSchema = z
-    .hash('sha256', {
-    error: 'Must be a SHA256 hash as 32-byte hex string',
-})
-    .meta({
-    format: undefined,
-    title: 'SHA256 Hash',
-    description: 'SHA-256 cryptographic hash as hexadecimal string',
-    examples: [
-        '87f633634cc4b02f628685651f0a29b7bfa22a0bd841f725c6772dd00a58d489',
-        '6e83b8e6373847bbdc056549bedda38dc88854ce41ba4fca11e0fc6ce3e07ef6',
-    ],
-});
-export const Keccak256HashSchema = Sha256HashSchema.meta({
-    title: 'Keccak256 Hash',
-    description: 'Keccak256 cryptographic hash as hexadecimal string',
-    examples: [
-        'ac08c3cf2e175e55961d6affdb38bc24591b84ceef7f3707c69ae3d52c148b2f',
-        'b1c2d3e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2',
-    ],
-});
-export const ExternalIdSchema = UuidSchema.meta({
-    title: 'External ID',
-    description: 'UUID identifier for external system references',
-    examples: [
-        'ad44dd3f-f176-4b98-bf78-5ee6e77d0530',
-        'b2c4e6f8-a1b3-4c5d-9e8f-123456789abc',
-    ],
-});
-export const ExternalUrlSchema = z.url('Must be a valid URL').meta({
-    title: 'External URL',
-    description: 'Valid URL pointing to external resources',
-    examples: [
-        'https://explore.carrot.eco/document/ad44dd3f-f176-4b98-bf78-5ee6e77d0530',
-        'https://carrot.eco/whitepaper.pdf',
-    ],
-});
-export const RecordSchemaTypeSchema = z
-    .enum([
-    'MassID',
-    'MassID Audit',
-    'RecycledID',
-    'GasID',
-    'PurchaseID',
-    'Methodology',
-    'Credit',
-    'Collection',
-])
-    .meta({
-    title: 'Schema Type',
-    description: 'Type of schema in the Carrot ecosystem',
-    examples: ['MassID', 'RecycledID', 'GasID'],
-});
-export const TokenSymbolSchema = NonEmptyStringSchema.max(10)
-    .regex(/^[A-Z0-9-]+$/, 'Must contain only uppercase letters, numbers, and hyphens')
-    .meta({
-    title: 'Token Symbol',
-    description: 'Symbol representing a token or cryptocurrency',
-    examples: ['MASS', 'REC', 'GAS'],
-});
-export const RecordRelationshipTypeSchema = z
-    .enum([
-    'collection',
-    'credit',
-    'gas-id',
-    'mass-id',
-    'mass-id-audit',
-    'methodology',
-    'purchase-id',
-    'recycled-id',
-])
-    .meta({
-    title: 'Relationship Type',
-    description: 'Type of relationship between different entities in the system',
-    examples: ['mass-id', 'audit', 'collection'],
-});

package/dist/shared/entities/location.schema.d.ts

@@ -1,55 +0,0 @@
-import { z } from 'zod';
-declare const PrecisionLevelSchema: z.ZodEnum<{
-    exact: "exact";
-    neighborhood: "neighborhood";
-    city: "city";
-    region: "region";
-    country: "country";
-}>;
-export type PrecisionLevel = z.infer<typeof PrecisionLevelSchema>;
-export declare const CoordinatesSchema: z.ZodObject<{
-    latitude: z.ZodNumber;
-    longitude: z.ZodNumber;
-    precision_level: z.ZodEnum<{
-        exact: "exact";
-        neighborhood: "neighborhood";
-        city: "city";
-        region: "region";
-        country: "country";
-    }>;
-}, z.core.$strict>;
-export type Coordinates = z.infer<typeof CoordinatesSchema>;
-export declare const LocationSchema: z.ZodObject<{
-    id: z.ZodUUID;
-    municipality: z.ZodString;
-    administrative_division: z.ZodString;
-    administrative_division_code: z.ZodOptional<z.ZodString>;
-    country: z.ZodString;
-    country_code: z.ZodString;
-    responsible_participant_id: z.ZodUUID;
-    coordinates: z.ZodObject<{
-        latitude: z.ZodNumber;
-        longitude: z.ZodNumber;
-        precision_level: z.ZodEnum<{
-            exact: "exact";
-            neighborhood: "neighborhood";
-            city: "city";
-            region: "region";
-            country: "country";
-        }>;
-    }, z.core.$strict>;
-    facility_type: z.ZodOptional<z.ZodEnum<{
-        "Waste Generation": "Waste Generation";
-        "Collection Point": "Collection Point";
-        "Transfer Station": "Transfer Station";
-        "Sorting Facility": "Sorting Facility";
-        "Composting Facility": "Composting Facility";
-        "Recycling Facility": "Recycling Facility";
-        "Processing Facility": "Processing Facility";
-        "Disposal Facility": "Disposal Facility";
-        "Administrative Office": "Administrative Office";
-    }>>;
-}, z.core.$strict>;
-export type Location = z.infer<typeof LocationSchema>;
-export {};
-//# sourceMappingURL=location.schema.d.ts.map

package/dist/shared/entities/location.schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"location.schema.d.ts","sourceRoot":"","sources":["../../../src/shared/entities/location.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,QAAA,MAAM,oBAAoB;;;;;;EAMtB,CAAC;AAEL,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,iBAAiB;;;;;;;;;;kBAe1B,CAAC;AACL,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA2CvB,CAAC;AAEL,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/shared/entities/location.schema.js

@@ -1,68 +0,0 @@
-import { z } from 'zod';
-import { UuidSchema, NonEmptyStringSchema, LatitudeSchema, LongitudeSchema, IsoCountryCodeSchema, IsoAdministrativeDivisionCodeSchema, FacilityTypeSchema, } from '../definitions.schema.js';
-const PrecisionLevelSchema = z
-    .enum(['exact', 'neighborhood', 'city', 'region', 'country'])
-    .meta({
-    title: 'Precision Level',
-    description: 'Level of coordinate precision',
-    examples: ['city', 'exact', 'neighborhood'],
-});
-export const CoordinatesSchema = z
-    .strictObject({
-    latitude: LatitudeSchema.meta({
-        title: 'Latitude',
-        description: 'GPS latitude coordinate',
-    }),
-    longitude: LongitudeSchema.meta({
-        title: 'Longitude',
-        description: 'GPS longitude coordinate',
-    }),
-    precision_level: PrecisionLevelSchema,
-})
-    .meta({
-    title: 'Coordinates',
-    description: 'GPS coordinates of the location',
-});
-export const LocationSchema = z
-    .strictObject({
-    id: UuidSchema.meta({
-        title: 'Location ID',
-        description: 'Unique identifier for the location',
-    }),
-    municipality: NonEmptyStringSchema.max(50).meta({
-        title: 'Municipality',
-        description: 'Municipality or city name',
-        examples: ['New York', 'São Paulo', 'London', 'Tokyo'],
-    }),
-    administrative_division: NonEmptyStringSchema.max(50).meta({
-        title: 'Administrative Division',
-        description: 'State, province, or administrative region',
-        examples: ['California', 'Ontario', 'Bavaria', 'Queensland'],
-    }),
-    administrative_division_code: IsoAdministrativeDivisionCodeSchema.optional().meta({
-        title: 'Administrative Division Code',
-        description: 'ISO 3166-2 administrative division code',
-    }),
-    country: NonEmptyStringSchema.max(50).meta({
-        title: 'Country',
-        description: 'Full country name in English',
-        examples: ['United States', 'Canada', 'Germany', 'Australia'],
-    }),
-    country_code: IsoCountryCodeSchema.meta({
-        title: 'Country Code',
-        description: 'ISO 3166-1 alpha-2 country code',
-    }),
-    responsible_participant_id: UuidSchema.meta({
-        title: 'Responsible Participant ID',
-        description: 'ID of the participant responsible for this location',
-    }),
-    coordinates: CoordinatesSchema,
-    facility_type: FacilityTypeSchema.optional().meta({
-        title: 'Facility Type',
-        description: 'Type of facility at this location',
-    }),
-})
-    .meta({
-    title: 'Location',
-    description: 'Geographic location with address and coordinate information',
-});

package/dist/shared/entities/participant.schema.d.ts

@@ -1,8 +0,0 @@
-import { z } from 'zod';
-export declare const ParticipantSchema: z.ZodObject<{
-    id: z.ZodUUID;
-    name: z.ZodString;
-    roles: z.ZodArray<z.ZodString>;
-}, z.core.$strict>;
-export type Participant = z.infer<typeof ParticipantSchema>;
-//# sourceMappingURL=participant.schema.d.ts.map

package/dist/shared/entities/participant.schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"participant.schema.d.ts","sourceRoot":"","sources":["../../../src/shared/entities/participant.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,iBAAiB;;;;kBAwB1B,CAAC;AAEL,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/shared/entities/participant.schema.js

@@ -1,24 +0,0 @@
-import { z } from 'zod';
-import { UuidSchema, ParticipantNameSchema, ParticipantRoleSchema, } from '../definitions.schema.js';
-import { uniqueArrayItems } from '../helpers.schema.js';
-export const ParticipantSchema = z
-    .strictObject({
-    id: UuidSchema.meta({
-        title: 'Participant ID',
-        description: 'Unique identifier for the participant',
-    }),
-    name: ParticipantNameSchema.meta({
-        title: 'Participant Name',
-        description: 'Name of the participant',
-    }),
-    roles: uniqueArrayItems(ParticipantRoleSchema, 'Participant roles must be unique')
-        .min(1)
-        .meta({
-        title: 'Participant Roles',
-        description: 'Roles of the participant in the waste management supply chain',
-    }),
-})
-    .meta({
-    title: 'Participant',
-    description: 'A participant in the waste management supply chain',
-});

package/dist/shared/helpers.schema.d.ts

@@ -1,4 +0,0 @@
-import { z } from 'zod';
-export declare function uniqueArrayItems<T extends z.ZodTypeAny>(schema: T, errorMessage?: string): z.ZodArray<T>;
-export declare function uniqueBy<T extends z.ZodTypeAny, K>(schema: T, selector: (item: z.infer<T>) => K, errorMessage?: string): z.ZodArray<T>;
-//# sourceMappingURL=helpers.schema.d.ts.map

package/dist/shared/helpers.schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"helpers.schema.d.ts","sourceRoot":"","sources":["../../src/shared/helpers.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EACrD,MAAM,EAAE,CAAC,EACT,YAAY,GAAE,MAAqC,iBAOpD;AAED,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,CAAC,EAChD,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,EACjC,YAAY,GAAE,MAA+B,iBAW9C"}

package/dist/shared/helpers.schema.js

@@ -1,16 +0,0 @@
-import { z } from 'zod';
-export function uniqueArrayItems(schema, errorMessage = 'Array items must be unique') {
-    return z
-        .array(schema)
-        .refine((items) => new Set(items).size === items.length, {
-        message: errorMessage,
-    });
-}
-export function uniqueBy(schema, selector, errorMessage = 'Items must be unique') {
-    return z.array(schema).refine((items) => {
-        const values = items.map(selector);
-        return new Set(values).size === values.length;
-    }, {
-        message: errorMessage,
-    });
-}

package/dist/shared/nft.schema.d.ts

@@ -1,116 +0,0 @@
-import { z } from 'zod';
-declare const NftSchemaTypeSchema: z.ZodEnum<{
-    MassID: "MassID";
-    RecycledID: "RecycledID";
-    GasID: "GasID";
-    PurchaseID: "PurchaseID";
-}>;
-export type NftSchemaType = z.infer<typeof NftSchemaTypeSchema>;
-declare const BlockchainReferenceSchema: z.ZodObject<{
-    smart_contract_address: z.ZodString;
-    chain_id: z.ZodNumber;
-    network_name: z.ZodString;
-    token_id: z.ZodString;
-}, z.core.$strict>;
-export type BlockchainReference = z.infer<typeof BlockchainReferenceSchema>;
-declare const ExternalLinkSchema: z.ZodObject<{
-    label: z.ZodString;
-    url: z.ZodURL;
-    description: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export type ExternalLink = z.infer<typeof ExternalLinkSchema>;
-declare const NftAttributeSchema: z.ZodObject<{
-    trait_type: z.ZodString;
-    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
-    display_type: z.ZodOptional<z.ZodEnum<{
-        number: "number";
-        date: "date";
-        boost_number: "boost_number";
-        boost_percentage: "boost_percentage";
-    }>>;
-    max_value: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>;
-export type NftAttribute = z.infer<typeof NftAttributeSchema>;
-export declare const NftIpfsSchema: z.ZodObject<{
-    $schema: z.ZodURL;
-    created_at: z.ZodISODateTime;
-    external_id: z.ZodUUID;
-    external_url: z.ZodURL;
-    original_content_hash: z.ZodCustomStringFormat<"sha256_hex">;
-    content_hash: z.ZodCustomStringFormat<"sha256_hex">;
-    creator: z.ZodOptional<z.ZodObject<{
-        name: z.ZodString;
-        id: z.ZodUUID;
-    }, z.core.$strict>>;
-    relationships: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        target_uri: z.ZodString;
-        type: z.ZodEnum<{
-            collection: "collection";
-            credit: "credit";
-            "gas-id": "gas-id";
-            "mass-id": "mass-id";
-            "mass-id-audit": "mass-id-audit";
-            methodology: "methodology";
-            "purchase-id": "purchase-id";
-            "recycled-id": "recycled-id";
-        }>;
-        description: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>>;
-    environment: z.ZodOptional<z.ZodObject<{
-        blockchain_network: z.ZodEnum<{
-            mainnet: "mainnet";
-            testnet: "testnet";
-        }>;
-        deployment: z.ZodEnum<{
-            production: "production";
-            development: "development";
-            testing: "testing";
-        }>;
-        data_set_name: z.ZodEnum<{
-            TEST: "TEST";
-            PROD: "PROD";
-        }>;
-    }, z.core.$strict>>;
-    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    schema: z.ZodObject<{
-        hash: z.ZodCustomStringFormat<"sha256_hex">;
-        version: z.ZodString;
-        type: z.ZodEnum<{
-            MassID: "MassID";
-            RecycledID: "RecycledID";
-            GasID: "GasID";
-            PurchaseID: "PurchaseID";
-        }>;
-    }, z.core.$strict>;
-    blockchain: z.ZodObject<{
-        smart_contract_address: z.ZodString;
-        chain_id: z.ZodNumber;
-        network_name: z.ZodString;
-        token_id: z.ZodString;
-    }, z.core.$strict>;
-    name: z.ZodString;
-    short_name: z.ZodString;
-    description: z.ZodString;
-    image: z.ZodString;
-    background_color: z.ZodOptional<z.ZodString>;
-    animation_url: z.ZodOptional<z.ZodString>;
-    external_links: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        label: z.ZodString;
-        url: z.ZodURL;
-        description: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>>;
-    attributes: z.ZodArray<z.ZodObject<{
-        trait_type: z.ZodString;
-        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
-        display_type: z.ZodOptional<z.ZodEnum<{
-            number: "number";
-            date: "date";
-            boost_number: "boost_number";
-            boost_percentage: "boost_percentage";
-        }>>;
-        max_value: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type NftIpfs = z.infer<typeof NftIpfsSchema>;
-export {};
-//# sourceMappingURL=nft.schema.d.ts.map

package/dist/shared/nft.schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nft.schema.d.ts","sourceRoot":"","sources":["../../src/shared/nft.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB,QAAA,MAAM,mBAAmB;;;;;EAQvB,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,QAAA,MAAM,yBAAyB;;;;;kBAqB3B,CAAC;AAEL,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,QAAA,MAAM,kBAAkB;;;;kBAkBpB,CAAC;AAEL,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,QAAA,MAAM,kBAAkB;;;;;;;;;;kBAyBpB,CAAC;AAEL,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA0HxB,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}