diff --git a/.github/workflows/cicd.yaml b/.github/workflows/cicd.yaml index 9592686..fe9ccb9 100644 --- a/.github/workflows/cicd.yaml +++ b/.github/workflows/cicd.yaml @@ -51,7 +51,7 @@ jobs: steps: - name: Checkout code uses: actions/checkout@v3 - + - name: Configure AWS credentials uses: aws-actions/configure-aws-credentials@v1 with: @@ -78,7 +78,7 @@ jobs: steps: - name: Checkout code uses: actions/checkout@v3 - + - name: Configure AWS credentials uses: aws-actions/configure-aws-credentials@v1 with: @@ -111,7 +111,7 @@ jobs: key: ${{ secrets.VPS_SSH_KEY }} script: | cd /home/${{ secrets.VPS_USERNAME }}/credential-showcase-api - + # Deploy API server if changed if [[ "${{ needs.determine-changes.outputs.api_server }}" == "true" ]]; then export TAG=${{ github.sha }} && sudo -E docker compose -f docker/dev/docker-compose.yml pull credential-showcase-api-server diff --git a/.husky/pre-commit b/.husky/pre-commit index 3c19b90..513ca56 100755 --- a/.husky/pre-commit +++ b/.husky/pre-commit @@ -1 +1,22 @@ +# Check if prettier would make changes +if ! pnpm prettier --check; then + echo "Error: Prettier check failed. Please format your code before committing." + echo "You can run 'pnpm prettier' to fix formatting issues." + exit 1 +fi + +# Stash unstaged and untracked changes, keeping staged files intact +stash_ref=$(git stash push --keep-index --include-untracked -m "pre-commit-$(date +%s)") +echo "Saved unstaged files to stash, ref: $stash_ref" + +# Run prettier formatting pnpm prettier + +# Stage only prettier modified files +git add -u + +# Restore unstaged changes from stash, if any +if [ "$stash_ref" != "No local changes to save" ]; then + echo "Restoring stash" + git stash pop >/dev/null 2>&1 +fi \ No newline at end of file diff --git a/README.md b/README.md index 036c94e..34a7488 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,7 @@ A TypeScript-based monorepo for the Credential Showcase API, consisting of backe # credential-showcase-api-server -the backend server for the Credential Showcase application. It provides REST API endpoints for managing and showcasing credentials. +the backend server for the Credential Showcase application. It provides REST API endpoints for managing and showcasing credentials. # credential-showcase-openapi diff --git a/apps/credential-showcase-api-server/package.json b/apps/credential-showcase-api-server/package.json index b4b0ac1..e8f610f 100644 --- a/apps/credential-showcase-api-server/package.json +++ b/apps/credential-showcase-api-server/package.json @@ -6,7 +6,7 @@ "types": "dist/index.d.ts", "scripts": { "start": "ts-node src/index.ts", - "dev": "ts-node-dev src/index.ts", + "dev": "ts-node-dev --transpile-only src/index.ts", "build": "tsc", "build:clean": "tsc --build --clean && tsc --build", "migration:generate": "npx drizzle-kit generate --config=drizzle.config.ts --name=credential-showcase-api" diff --git a/apps/credential-showcase-api-server/src/controllers/ShowcaseController.ts b/apps/credential-showcase-api-server/src/controllers/ShowcaseController.ts index 9664d9f..b5bd6ab 100644 --- a/apps/credential-showcase-api-server/src/controllers/ShowcaseController.ts +++ b/apps/credential-showcase-api-server/src/controllers/ShowcaseController.ts @@ -1,16 +1,18 @@ -import { BadRequestError, Body, Delete, Get, HttpCode, JsonController, OnUndefined, Param, Post, Put } from 'routing-controllers' +import { BadRequestError, Body, Delete, Get, HttpCode, JsonController, OnUndefined, Param, Post, Put, QueryParam } from 'routing-controllers' import { Service } from 'typedi' import { - ShowcaseResponse, - ShowcaseResponseFromJSONTyped, + instanceOfShowcaseRequest, + ShowcaseExpand, ShowcaseRequest, ShowcaseRequestToJSONTyped, + ShowcaseResponse, + ShowcaseResponseFromJSONTyped, ShowcasesResponse, ShowcasesResponseFromJSONTyped, - instanceOfShowcaseRequest, } from 'credential-showcase-openapi' -import ShowcaseService from '../services/ShowcaseService' import { showcaseDTOFrom } from '../utils/mappers' +import { normalizeExpandParams } from '../utils/normalize' +import { ShowcaseService } from '../services/ShowcaseService' @JsonController('/showcases') @Service() @@ -18,9 +20,9 @@ class ShowcaseController { constructor(private showcaseService: ShowcaseService) {} @Get('/') - public async getAll(): Promise { + public async getAll(@QueryParam('expand') expand?: ShowcaseExpand[]): Promise { try { - const result = await this.showcaseService.getShowcases() + const result = await this.showcaseService.getShowcases({ expand: normalizeExpandParams(expand) }) const showcases = result.map((showcase) => showcaseDTOFrom(showcase)) return ShowcasesResponseFromJSONTyped({ showcases }, false) } catch (e) { @@ -32,10 +34,10 @@ class ShowcaseController { } @Get('/:slug') - public async getOne(@Param('slug') slug: string): Promise { - const id = await this.showcaseService.getIdBySlug(slug) + public async getOne(@Param('slug') slug: string, @QueryParam('expand') expand?: ShowcaseExpand[]): Promise { + const id = await this.showcaseService.getIdBySlug({ slug }) try { - const result = await this.showcaseService.getShowcase(id) + const result = await this.showcaseService.getShowcase({ id, expand: normalizeExpandParams(expand) }) return ShowcaseResponseFromJSONTyped({ showcase: showcaseDTOFrom(result) }, false) } catch (e) { if (e.httpCode !== 404) { @@ -52,7 +54,7 @@ class ShowcaseController { if (!instanceOfShowcaseRequest(showcaseRequest)) { return Promise.reject(new BadRequestError()) } - const result = await this.showcaseService.createShowcase(ShowcaseRequestToJSONTyped(showcaseRequest)) + const result = await this.showcaseService.createShowcase({ showcase: ShowcaseRequestToJSONTyped(showcaseRequest) }) return ShowcaseResponseFromJSONTyped({ showcase: showcaseDTOFrom(result) }, false) } catch (e) { if (e.httpCode !== 404) { @@ -64,12 +66,13 @@ class ShowcaseController { @Put('/:slug') public async put(@Param('slug') slug: string, @Body() showcaseRequest: ShowcaseRequest): Promise { - const id = await this.showcaseService.getIdBySlug(slug) + const id = await this.showcaseService.getIdBySlug({ slug }) try { if (!instanceOfShowcaseRequest(showcaseRequest)) { return Promise.reject(new BadRequestError()) } - const result = await this.showcaseService.updateShowcase(id, ShowcaseRequestToJSONTyped(showcaseRequest)) + const result = await this.showcaseService.updateShowcase({ id, showcase: ShowcaseRequestToJSONTyped(showcaseRequest) }) + return ShowcaseResponseFromJSONTyped({ showcase: showcaseDTOFrom(result) }, false) } catch (e) { if (e.httpCode !== 404) { @@ -82,9 +85,9 @@ class ShowcaseController { @OnUndefined(204) @Delete('/:slug') public async delete(@Param('slug') slug: string): Promise { - const id = await this.showcaseService.getIdBySlug(slug) + const id = await this.showcaseService.getIdBySlug({ slug }) try { - return this.showcaseService.deleteShowcase(id) + return this.showcaseService.deleteShowcase({ id }) } catch (e) { if (e.httpCode !== 404) { console.error(`Delete showcase id=${id} failed:`, e) diff --git a/apps/credential-showcase-api-server/src/controllers/__tests__/ShowcaseController.integration.test.ts b/apps/credential-showcase-api-server/src/controllers/__tests__/ShowcaseController.integration.test.ts index 171db71..bf91254 100644 --- a/apps/credential-showcase-api-server/src/controllers/__tests__/ShowcaseController.integration.test.ts +++ b/apps/credential-showcase-api-server/src/controllers/__tests__/ShowcaseController.integration.test.ts @@ -11,51 +11,24 @@ import IssuerRepository from '../../database/repositories/IssuerRepository' import PersonaRepository from '../../database/repositories/PersonaRepository' import ScenarioRepository from '../../database/repositories/ScenarioRepository' import ShowcaseRepository from '../../database/repositories/ShowcaseRepository' -import ShowcaseService from '../../services/ShowcaseService' -import { ShowcaseRequest } from 'credential-showcase-openapi' -import supertest = require('supertest') +import { ShowcaseService } from '../../services/ShowcaseService' +import { Showcase, ShowcaseExpand, ShowcaseRequest } from 'credential-showcase-openapi' import { PGlite } from '@electric-sql/pglite' import { drizzle } from 'drizzle-orm/pglite' import * as schema from '../../database/schema' import { NodePgDatabase } from 'drizzle-orm/node-postgres' import { migrate } from 'drizzle-orm/node-postgres/migrator' import DatabaseService from '../../services/DatabaseService' +import { Buffer } from 'buffer' +import supertest = require('supertest') describe('ShowcaseController Integration Tests', () => { let client: PGlite let app: Application let request: any - beforeAll(async () => { - client = new PGlite() - const database = drizzle(client, { schema }) as unknown as NodePgDatabase - await migrate(database, { migrationsFolder: './apps/credential-showcase-api-server/src/database/migrations' }) - const mockDatabaseService = { - getConnection: jest.fn().mockResolvedValue(database), - } - Container.set(DatabaseService, mockDatabaseService) - useContainer(Container) - Container.get(AssetRepository) - Container.get(CredentialSchemaRepository) - Container.get(CredentialDefinitionRepository) - Container.get(IssuerRepository) - Container.get(PersonaRepository) - Container.get(ScenarioRepository) - Container.get(ShowcaseRepository) - Container.get(ShowcaseService) - app = createExpressServer({ - controllers: [ShowcaseController], - }) - request = supertest(app) - }) - - afterAll(async () => { - await client.close() - Container.reset() - }) - - it('should create, retrieve, update, and delete a showcase', async () => { - // Create prerequisites: asset, credential schema, credential definition, issuer, persona, and scenario + // Helper function to create common prerequisites + async function createTestPrerequisites() { const assetRepository = Container.get(AssetRepository) const asset = await assetRepository.create({ mediaType: 'image/png', @@ -152,7 +125,41 @@ describe('ShowcaseController Integration Tests', () => { hidden: false, }) - // 1. Create a showcase + return { asset, credentialSchema, credentialDefinition, issuer, persona, scenario } + } + + beforeAll(async () => { + client = new PGlite() + const database = drizzle(client, { schema }) as unknown as NodePgDatabase + await migrate(database, { migrationsFolder: './apps/credential-showcase-api-server/src/database/migrations' }) + const mockDatabaseService = { + getConnection: jest.fn().mockResolvedValue(database), + } + Container.set(DatabaseService, mockDatabaseService) + useContainer(Container) + // Initialize all repositories and services + Container.get(AssetRepository) + Container.get(CredentialSchemaRepository) + Container.get(CredentialDefinitionRepository) + Container.get(IssuerRepository) + Container.get(PersonaRepository) + Container.get(ScenarioRepository) + Container.get(ShowcaseRepository) + Container.get(ShowcaseService) + app = createExpressServer({ + controllers: [ShowcaseController], + }) + request = supertest(app) + }) + + afterAll(async () => { + await client.close() + Container.reset() + }) + + it('should create, retrieve, update, and delete a showcase', async () => { + const { asset, credentialDefinition, persona, scenario } = await createTestPrerequisites() + const showcaseRequest: ShowcaseRequest = { name: 'Test Showcase', description: 'Test showcase description', @@ -195,17 +202,12 @@ describe('ShowcaseController Integration Tests', () => { } const updateResponse = await request.put(`/showcases/${createdShowcase.slug}`).send(updatedRequest).expect(200) - const updatedShowcase = updateResponse.body.showcase - expect(updateResponse.body.showcase.name).toEqual('Updated Showcase Name') expect(updateResponse.body.showcase.description).toEqual('Updated showcase description') expect(updateResponse.body.showcase.status).toEqual(ShowcaseStatus.PENDING) - // 5. Delete the showcase - await request.delete(`/showcases/${updatedShowcase.slug}`).expect(204) - - // 6. Verify showcase deletion - await request.get(`/showcases/${updatedShowcase.slug}`).expect(404) + await request.delete(`/showcases/${updateResponse.body.showcase.slug}`).expect(204) + await request.get(`/showcases/${updateResponse.body.showcase.slug}`).expect(404) }) it('should handle errors when accessing non-existent resources', async () => { @@ -237,4 +239,320 @@ describe('ShowcaseController Integration Tests', () => { await request.post('/showcases').send(invalidShowcaseRequest2).expect(404) }) + + it('should retrieve a showcase with no expands', async () => { + const { asset, scenario } = await createTestPrerequisites() + const { credentialDefinition, persona } = await createTestPrerequisites() + + const showcaseRequest: ShowcaseRequest = { + name: 'Expand Test Showcase', + description: 'Testing expand options', + status: ShowcaseStatus.ACTIVE, + hidden: false, + scenarios: [scenario.id], + credentialDefinitions: [credentialDefinition.id], + personas: [persona.id], + bannerImage: asset.id, + completionMessage: 'Completion message', + } + + const createResponse = await request.post('/showcases').send(showcaseRequest).expect(201) + const createdShowcase = createResponse.body.showcase + + // Retrieve without any expands + const getResponse = await request.get(`/showcases/${createdShowcase.slug}`).expect(200) + + // Verify related entities have IDs but no expanded content + expect(getResponse.body.showcase.scenarios).toHaveLength(1) + expect(getResponse.body.showcase.scenarios[0]).toHaveProperty('id') + expect(getResponse.body.showcase.credentialDefinitions).toHaveLength(1) + expect(getResponse.body.showcase.credentialDefinitions[0]).toHaveProperty('id') + expect(getResponse.body.showcase.personas).toHaveLength(1) + expect(getResponse.body.showcase.personas[0]).toHaveProperty('id') + expect(getResponse.body.showcase.bannerImage).toHaveProperty('id') + expect(Object.keys(getResponse.body.showcase.bannerImage).length).toBe(1) // Only contains id + }) + + it('should retrieve a showcase with all expands except asset content', async () => { + const { asset, scenario, credentialDefinition, persona } = await createTestPrerequisites() + const showcaseRequest: ShowcaseRequest = { + name: 'All Expands Showcase', + description: 'Testing all expands except asset content', + status: ShowcaseStatus.ACTIVE, + hidden: false, + scenarios: [scenario.id], + credentialDefinitions: [credentialDefinition.id], + personas: [persona.id], + bannerImage: asset.id, + completionMessage: 'Testing completion message', + } + + const createResponse = await request.post('/showcases').send(showcaseRequest).expect(201) + const createdShowcase = createResponse.body.showcase + + // Retrieve with all expands except asset content + const getResponse = await request + .get( + `/showcases/${createdShowcase.slug}?expand=${ShowcaseExpand.Scenarios}&expand=${ShowcaseExpand.CredentialDefinitions}&expand=${ShowcaseExpand.Personas}`, + ) + .expect(200) + + // Verify related entities are expanded + expect(getResponse.body.showcase.scenarios.length).toEqual(1) + expect(getResponse.body.showcase.credentialDefinitions.length).toEqual(1) + expect(getResponse.body.showcase.personas.length).toEqual(1) + + // Verify completionMessage is preserved + expect(getResponse.body.showcase.completionMessage).toEqual('Testing completion message') + + // Verify banner image is a string ID without content + expect(getResponse.body.showcase.bannerImage).toHaveProperty('id') + expect(getResponse.body.showcase.bannerImage).not.toHaveProperty('content') + // Check that persona image references are objects with id + const responsePersona = getResponse.body.showcase.personas[0] + expect(responsePersona.headshotImage).toHaveProperty('id') + expect(responsePersona.headshotImage).not.toHaveProperty('content') + expect(responsePersona.bodyImage).toHaveProperty('id') + expect(responsePersona.bodyImage).not.toHaveProperty('content') + // Check that scenario assets are objects with id + const step = getResponse.body.showcase.scenarios[0].steps[0] + expect(step.asset).toHaveProperty('id') + }) + + it('should retrieve a showcase with all expands including asset content', async () => { + const { asset, scenario, credentialDefinition, persona } = await createTestPrerequisites() + const showcaseRequest: ShowcaseRequest = { + name: 'Assets Content Showcase', + description: 'Testing all expands with asset content', + status: ShowcaseStatus.ACTIVE, + hidden: false, + scenarios: [scenario.id], + credentialDefinitions: [credentialDefinition.id], + personas: [persona.id], + bannerImage: asset.id, + completionMessage: 'Asset content test completion message', + } + + const createResponse = await request.post('/showcases').send(showcaseRequest).expect(201) + const createdShowcase = createResponse.body.showcase + + // Retrieve with all expands including asset content + const getResponse = await request + .get( + `/showcases/${createdShowcase.slug}?expand=${ShowcaseExpand.Scenarios}&expand=${ShowcaseExpand.CredentialDefinitions}&expand=${ShowcaseExpand.Personas}&expand=${ShowcaseExpand.AssetContent}`, + ) + .expect(200) + + // Verify related entities are expanded + expect(getResponse.body.showcase.scenarios.length).toEqual(1) + expect(getResponse.body.showcase.credentialDefinitions.length).toEqual(1) + expect(getResponse.body.showcase.personas.length).toEqual(1) + + // Verify completionMessage is preserved + expect(getResponse.body.showcase.completionMessage).toEqual('Asset content test completion message') + + // Verify banner image is an object with content + expect(typeof getResponse.body.showcase.bannerImage).toBe('object') + expect(getResponse.body.showcase.bannerImage).toHaveProperty('id') + expect(getResponse.body.showcase.bannerImage).toHaveProperty('mediaType') + expect(getResponse.body.showcase.bannerImage).toHaveProperty('fileName') + expect(getResponse.body.showcase.bannerImage).toHaveProperty('content') + + // Check that persona image references have content + const responsePersona = getResponse.body.showcase.personas[0] + expect(typeof responsePersona.headshotImage).toBe('object') + expect(responsePersona.headshotImage).toHaveProperty('content') + expect(typeof responsePersona.bodyImage).toBe('object') + expect(responsePersona.bodyImage).toHaveProperty('content') + + // Check that scenario assets have content + const step = getResponse.body.showcase.scenarios[0].steps[0] + expect(typeof step.asset).toBe('object') + expect(step.asset).toHaveProperty('content') + }) + + it('should retrieve all showcases with various expand combinations', async () => { + const { asset, credentialSchema } = await createTestPrerequisites() + + const credentialDefinitionRepository = Container.get(CredentialDefinitionRepository) + const credentialDefinition = await credentialDefinitionRepository.create({ + name: 'Test Definition', + version: '1.0', + identifierType: IdentifierType.DID, + identifier: 'did:test:123', + icon: asset.id, + type: CredentialType.ANONCRED, + credentialSchema: credentialSchema.id, + }) + + const issuerRepository = Container.get(IssuerRepository) + const issuer = await issuerRepository.create({ + name: 'Test Issuer', + type: IssuerType.ARIES, + credentialDefinitions: [credentialDefinition.id], + credentialSchemas: [credentialSchema.id], + description: 'Test issuer description', + organization: 'Test Organization', + logo: asset.id, + }) + + // Create a persona + const personaRepository = Container.get(PersonaRepository) + const persona = await personaRepository.create({ + name: 'John Doe', + role: 'Software Engineer', + description: 'Experienced developer', + headshotImage: asset.id, + bodyImage: asset.id, + hidden: false, + }) + + // Create an issuance scenario with at least one step + const scenarioRepository = Container.get(ScenarioRepository) + const scenario = await scenarioRepository.create({ + name: 'Test Scenario', + description: 'Test scenario description', + issuer: issuer.id, // This makes it an issuance scenario + steps: [ + { + title: 'Test Step', + description: 'Test step description', + order: 1, + type: StepType.HUMAN_TASK, + asset: asset.id, + actions: [ + { + title: 'Test Action', + actionType: StepActionType.ARIES_OOB, + text: 'Test action text', + proofRequest: { + attributes: { + attribute1: { + attributes: ['attribute1', 'attribute2'], + restrictions: ['restriction1', 'restriction2'], + }, + }, + predicates: {}, + }, + }, + ], + }, + ], + personas: [persona.id], + hidden: false, + }) + + // Create two showcases + const showcaseRequest1: ShowcaseRequest = { + name: 'First Test Showcase', + description: 'Testing expand options', + status: ShowcaseStatus.ACTIVE, + hidden: false, + scenarios: [scenario.id], + credentialDefinitions: [credentialDefinition.id], + personas: [persona.id], + bannerImage: asset.id, + completionMessage: 'First showcase completion message', + } + + const showcaseRequest2: ShowcaseRequest = { + name: 'Second Test Showcase', + description: 'Testing expand options', + status: ShowcaseStatus.ACTIVE, + hidden: false, + scenarios: [scenario.id], + credentialDefinitions: [credentialDefinition.id], + personas: [persona.id], + completionMessage: 'Second showcase completion message', + } + + await request.post('/showcases').send(showcaseRequest1).expect(201) + await request.post('/showcases').send(showcaseRequest2).expect(201) + + const response1 = await request.get('/showcases').expect(200) + expect(response1.body.showcases.length).toBeGreaterThanOrEqual(2) + expect(response1.body.showcases[0].scenarios.length).toBeGreaterThanOrEqual(1) + expect(response1.body.showcases[0].scenarios[0]).toHaveProperty('id') + expect(response1.body.showcases[0].credentialDefinitions.length).toBeGreaterThanOrEqual(1) + expect(response1.body.showcases[0].credentialDefinitions[0]).toHaveProperty('id') + expect(response1.body.showcases[0].personas.length).toBeGreaterThanOrEqual(1) + expect(response1.body.showcases[0].personas[0]).toHaveProperty('id') + expect(response1.body.showcases[0].completionMessage).toBeDefined() + + // Test 2: Get all with only scenarios expanded + const response2 = await request.get(`/showcases?expand=${ShowcaseExpand.Scenarios}`).expect(200) + expect(response2.body.showcases.length).toBeGreaterThanOrEqual(2) + expect(response2.body.showcases[0].scenarios.length).toBeGreaterThanOrEqual(1) + expect(response2.body.showcases[0].credentialDefinitions.length).toBeGreaterThanOrEqual(1) + expect(response2.body.showcases[0].credentialDefinitions[0]).toHaveProperty('id') + expect(response2.body.showcases[0].personas.length).toBeGreaterThanOrEqual(1) + expect(response2.body.showcases[0].personas[0]).toHaveProperty('id') + expect(response2.body.showcases[0].completionMessage).toBeDefined() + + // Test 3: Get all with scenarios and credential definitions expanded + const response3 = await request.get(`/showcases?expand=scenarios&expand=credentialdefinitions`).expect(200) // Test normalization + expect(response3.body.showcases.length).toBeGreaterThanOrEqual(2) + expect(response3.body.showcases[0].scenarios.length).toBeGreaterThanOrEqual(1) + expect(response3.body.showcases[0].credentialDefinitions.length).toBeGreaterThanOrEqual(1) + expect(response3.body.showcases[0].personas.length).toBeGreaterThanOrEqual(1) + expect(response3.body.showcases[0].personas[0]).toHaveProperty('id') + expect(response3.body.showcases[0].completionMessage).toBeDefined() + + // Test 4: Get all with all expands including asset content + const response4 = await request + .get( + `/showcases?expand=${ShowcaseExpand.Scenarios}&expand=${ShowcaseExpand.CredentialDefinitions}&expand=${ShowcaseExpand.Personas}&expand=${ShowcaseExpand.AssetContent}`, + ) + .expect(200) + expect(response4.body.showcases.length).toBeGreaterThanOrEqual(2) + expect(response4.body.showcases[0].scenarios.length).toBeGreaterThanOrEqual(1) + expect(response4.body.showcases[0].credentialDefinitions.length).toBeGreaterThanOrEqual(1) + expect(response4.body.showcases[0].personas.length).toBeGreaterThanOrEqual(1) + expect(response4.body.showcases[0].completionMessage).toBeDefined() + + // Check if at least one showcase has a banner image with content + const showcaseWithBanner = response4.body.showcases.find((showcase: Showcase) => showcase.bannerImage && typeof showcase.bannerImage === 'object') + if (showcaseWithBanner) { + expect(showcaseWithBanner.bannerImage).toHaveProperty('id') + expect(showcaseWithBanner.bannerImage).toHaveProperty('content') + } + }) + + it('should throw an error for invalid expand parameters', async () => { + const { asset, scenario, credentialDefinition, persona } = await createTestPrerequisites() + const showcaseRequest: ShowcaseRequest = { + name: 'Mixed Expand Test', + description: 'Testing mixed valid and invalid expand parameters', + status: ShowcaseStatus.ACTIVE, + hidden: false, + scenarios: [scenario.id], + credentialDefinitions: [credentialDefinition.id], + personas: [persona.id], + bannerImage: asset.id, + completionMessage: 'Test completion message', + } + + const createResponse = await request.post('/showcases').send(showcaseRequest).expect(201) + const createdShowcase = createResponse.body.showcase + + // Should now expect a 400 Bad Request error when using invalid expand parameter + await request + .get(`/showcases/${createdShowcase.slug}?expand=${ShowcaseExpand.Scenarios}&expand=invalidExpand&expand=${ShowcaseExpand.Personas}`) + .expect(400) + + // Test with only valid expand parameters + const validResponse = await request + .get(`/showcases/${createdShowcase.slug}?expand=${ShowcaseExpand.Scenarios}&expand=${ShowcaseExpand.Personas}`) + .expect(200) + + // Verify related entities have IDs but no expanded content + expect(validResponse.body.showcase.scenarios).toHaveLength(1) + expect(validResponse.body.showcase.scenarios[0]).toHaveProperty('id') + expect(validResponse.body.showcase.credentialDefinitions).toHaveLength(1) + expect(validResponse.body.showcase.credentialDefinitions[0]).toHaveProperty('id') + expect(validResponse.body.showcase.personas).toHaveLength(1) + expect(validResponse.body.showcase.personas[0]).toHaveProperty('id') + expect(validResponse.body.showcase.bannerImage).toHaveProperty('id') + expect(Object.keys(validResponse.body.showcase.bannerImage).length).toBe(1) // Only contains id + }) }) diff --git a/apps/credential-showcase-api-server/src/database/repositories/ShowcaseRepository.ts b/apps/credential-showcase-api-server/src/database/repositories/ShowcaseRepository.ts index 18a4ca0..3812739 100644 --- a/apps/credential-showcase-api-server/src/database/repositories/ShowcaseRepository.ts +++ b/apps/credential-showcase-api-server/src/database/repositories/ShowcaseRepository.ts @@ -1,4 +1,4 @@ -import { inArray, eq } from 'drizzle-orm' +import { eq, inArray } from 'drizzle-orm' import { Service } from 'typedi' import { BadRequestError } from 'routing-controllers' import DatabaseService from '../../services/DatabaseService' @@ -11,14 +11,28 @@ import { generateSlug } from '../../utils/slug' import { NotFoundError } from '../../errors' import { credentialDefinitions, - showcasesToCredentialDefinitions, - showcases, - scenarios, personas, + scenarios, + showcases, + showcasesToCredentialDefinitions, showcasesToPersonas, showcasesToScenarios, } from '../schema' -import { Showcase, NewShowcase, RepositoryDefinition } from '../../types' +import { + CredentialDefinition, + CredentialSchema, + Issuer, + NewShowcase, + Persona, + RelyingParty, + RepositoryDefinition, + Scenario, + Showcase, + ShowcaseExpand, + Step, +} from '../../types' + +type ShowcaseRow = typeof showcases.$inferSelect @Service() class ShowcaseRepository implements RepositoryDefinition { @@ -30,6 +44,7 @@ class ShowcaseRepository implements RepositoryDefinition private readonly assetRepository: AssetRepository, ) {} + // TODO should we return the asset objects, or just the IDs? async create(showcase: NewShowcase): Promise { if (showcase.personas.length === 0) { return Promise.reject(new BadRequestError('At least one persona is required')) @@ -212,13 +227,13 @@ class ShowcaseRepository implements RepositoryDefinition steps: sortSteps(scenario.steps), ...(scenario.relyingParty && { relyingParty: { - ...(scenario.relyingParty as any), // TODO check this typing issue at a later point in time + ...(scenario.relyingParty as object), credentialDefinitions: scenario.relyingParty!.cds.map((credentialDefinition) => credentialDefinition.cd), }, }), ...(scenario.issuer && { issuer: { - ...(scenario.issuer as any), // TODO check this typing issue at a later point in time + ...(scenario.issuer as any), credentialDefinitions: scenario.issuer!.cds.map((credentialDefinition) => credentialDefinition.cd), credentialSchemas: scenario.issuer!.css.map((credentialSchema) => credentialSchema.cs), }, @@ -240,6 +255,7 @@ class ShowcaseRepository implements RepositoryDefinition await (await this.databaseService.getConnection()).delete(showcases).where(eq(showcases.id, id)) } + // TODO should we return the asset objects, or just the IDs? async update(id: string, showcase: NewShowcase): Promise { await this.findById(id) if (showcase.personas.length === 0) { @@ -431,13 +447,13 @@ class ShowcaseRepository implements RepositoryDefinition steps: sortSteps(scenario.steps), ...(scenario.relyingParty && { relyingParty: { - ...(scenario.relyingParty as any), // TODO check this typing issue at a later point in time + ...(scenario.relyingParty as object), credentialDefinitions: scenario.relyingParty!.cds.map((credentialDefinition) => credentialDefinition.cd), }, }), ...(scenario.issuer && { issuer: { - ...(scenario.issuer as any), // TODO check this typing issue at a later point in time + ...(scenario.issuer as any), credentialDefinitions: scenario.issuer!.cds.map((credentialDefinition) => credentialDefinition.cd), credentialSchemas: scenario.issuer!.css.map((credentialSchema) => credentialSchema.cs), }, @@ -454,169 +470,300 @@ class ShowcaseRepository implements RepositoryDefinition }) } - async findById(id: string): Promise { - const prepared = (await this.databaseService.getConnection()).query.showcases - .findFirst({ - where: eq(showcases.id, id), + async findById(id: string, expand?: ShowcaseExpand[]): Promise { + const expandSet = new Set(expand || []) + let queryConfig = this.buildQueryConfigForId(id, expandSet) + + const connection = await this.databaseService.getConnection() + const result = await connection.query.showcases.findFirst(queryConfig) + + if (!result) { + return Promise.reject(new NotFoundError(`No showcase found for id: ${id}`)) + } + + // Create a typed showcase result + const showcase: Showcase = { + ...result, + scenarios: [], + credentialDefinitions: [], + personas: [], + } + + this.populateScenarios(result, expandSet, showcase) + this.populateCredentialDefs(result, expandSet, showcase) + this.populatePersonas(result, expandSet, showcase) + + return showcase + } + + private populatePersonas(result: ShowcaseRow, expandSet: Set, showcase: Showcase) { + if ('personas' in result && Array.isArray(result.personas)) { + if (expandSet.has(ShowcaseExpand.PERSONAS)) { + showcase.personas = result.personas.filter((personaJoin) => personaJoin.persona).map((personaJoin) => personaJoin.persona as Persona) + } else { + showcase.personas = result.personas.map((showcasesToPersona) => showcasesToPersona.persona) + } + } + } + + private populateCredentialDefs(result: ShowcaseRow, expandSet: Set, showcase: Showcase) { + if ('credentialDefinitions' in result && Array.isArray(result.credentialDefinitions)) { + if (expandSet.has(ShowcaseExpand.CREDENTIAL_DEFINITIONS)) { + const credentialDefinitionsArray: CredentialDefinition[] = [] + + for (const cdJoin of result.credentialDefinitions) { + if (!cdJoin.credentialDefinition) continue + + const cdObj = cdJoin.credentialDefinition + + credentialDefinitionsArray.push({ + ...cdObj, + credentialSchema: cdObj.cs, + } as CredentialDefinition) + } + + showcase.credentialDefinitions = credentialDefinitionsArray + } else { + showcase.credentialDefinitions = result.credentialDefinitions.map( + (showcaseToCredentialDefinition) => showcaseToCredentialDefinition.credentialDefinition, + ) + } + } + } + + private populateScenarios(result: ShowcaseRow, expandSet: Set, showcase: Showcase) { + if ('scenarios' in result && Array.isArray(result.scenarios)) { + if (expandSet.has(ShowcaseExpand.SCENARIOS)) { + showcase.scenarios = result.scenarios + .filter((scenarioJoin) => scenarioJoin.scenario) + .map((scenarioJoin) => { + const scenarioObj = scenarioJoin.scenario + + // Process steps if they exist + const processedSteps = scenarioObj.steps ? (sortSteps(scenarioObj.steps) as Step[]) : [] + + // Process relying party if it exists + const processedRelyingParty = scenarioObj.relyingParty + ? ({ + ...scenarioObj.relyingParty, + credentialDefinitions: scenarioObj.relyingParty.cds.map((cd: { cd: CredentialDefinition }) => cd.cd), + } as RelyingParty) + : undefined + + // Process issuer if it exists + const processedIssuer = scenarioObj.issuer + ? ({ + ...scenarioObj.issuer, + credentialDefinitions: scenarioObj.issuer.cds.map((cd: { cd: CredentialDefinition }) => cd.cd), + credentialSchemas: scenarioObj.issuer.css.map((cs: { cs: CredentialSchema }) => cs.cs), + } as Issuer) + : undefined + + // Process personas if they exist + const processedPersonas = scenarioObj.personas ? scenarioObj.personas.map((p: { persona: Persona }) => p.persona) : [] + + // Create the final scenario object with proper typing + const finalScenario: Scenario = { + ...scenarioObj, + steps: processedSteps, + personas: processedPersonas, + } + + // Add relying party and issuer conditionally + if (processedRelyingParty && 'relyingParty' in finalScenario) { + finalScenario.relyingParty = processedRelyingParty + } + + if (processedIssuer && 'issuer' in finalScenario) { + finalScenario.issuer = processedIssuer + } + + return finalScenario + }) + } else { + showcase.scenarios = result.scenarios.map((showcasesToScenario) => showcasesToScenario.scenario) + } + } + } + + private buildQueryConfigForId(id: string, expandSet: Set<'SCENARIOS' | 'CREDENTIAL_DEFINITIONS' | 'PERSONAS' | 'ASSET_CONTENT'>) { + // Define our query structure based on what should be included + let queryConfig: any = { + where: eq(showcases.id, id), + with: {}, + } + + if (expandSet.has(ShowcaseExpand.ASSET_CONTENT)) { + queryConfig.with.bannerImage = true + } + + // Add credentialDefinitions if needed + if (expandSet.has(ShowcaseExpand.CREDENTIAL_DEFINITIONS)) { + queryConfig.with.credentialDefinitions = { with: { - credentialDefinitions: { + credentialDefinition: { with: { - credentialDefinition: { + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) && { icon: true }), + cs: { with: { - icon: true, - cs: { - with: { - attributes: true, - }, - }, - representations: true, - revocation: true, + attributes: true, }, }, + representations: true, + revocation: true, }, }, - scenarios: { + }, + } + } else { + // Include only the credentialDefinitions join table without expanding the credentialDefinition entity + queryConfig.with.credentialDefinitions = { + columns: { + credentialDefinition: true, + }, + } + } + + // Add scenarios if needed + if (expandSet.has(ShowcaseExpand.SCENARIOS)) { + queryConfig.with.scenarios = { + with: { + scenario: { with: { - scenario: { + steps: { with: { - steps: { + actions: { with: { - actions: { - with: { - proofRequest: true, - }, - }, - asset: true, + proofRequest: true, }, }, - issuer: { + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { asset: true } : {}), + }, + }, + issuer: { + with: { + cds: { with: { - cds: { - with: { - cd: { - with: { - icon: true, - cs: { - with: { - attributes: true, - }, - }, - representations: true, - revocation: true, - }, - }, - }, - }, - css: { + cd: { with: { + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) && { icon: true }), cs: { with: { attributes: true, }, }, + representations: true, + revocation: true, }, }, - logo: true, }, }, - relyingParty: { + css: { with: { - cds: { + cs: { with: { - cd: { - with: { - icon: true, - cs: { - with: { - attributes: true, - }, - }, - representations: true, - revocation: true, - }, - }, + attributes: true, }, }, - logo: true, }, }, - personas: { + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { logo: true } : {}), + }, + }, + relyingParty: { + with: { + cds: { with: { - persona: { + cd: { with: { - headshotImage: true, - bodyImage: true, + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) && { icon: true }), + cs: { + with: { + attributes: true, + }, + }, + representations: true, + revocation: true, }, }, }, }, + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { logo: true } : {}), }, }, - }, - }, - personas: { - with: { - persona: { + personas: { with: { - headshotImage: true, - bodyImage: true, + persona: { + with: { + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) + ? { + headshotImage: true, + bodyImage: true, + } + : {}), + }, + }, }, }, }, }, - bannerImage: true, }, - }) - .prepare('statement_name') - - const result = await prepared.execute() - - if (!result) { - return Promise.reject(new NotFoundError(`No showcase found for id: ${id}`)) + } + } else { + // Include only the scenarios join table without expanding the scenario entity + queryConfig.with.scenarios = { + columns: { + scenario: true, + }, + } } - return { - ...result, - scenarios: result.scenarios.map((scenario) => ({ - ...(scenario.scenario as any), - steps: sortSteps(scenario.scenario.steps), - ...(scenario.scenario.relyingParty && { - relyingParty: { - ...(scenario.scenario.relyingParty as any), // TODO check this typing issue at a later point in time - credentialDefinitions: scenario.scenario.relyingParty!.cds.map((credentialDefinition) => credentialDefinition.cd), - }, - }), - ...(scenario.scenario.issuer && { - issuer: { - ...(scenario.scenario.issuer as any), // TODO check this typing issue at a later point in time - credentialDefinitions: scenario.scenario.issuer!.cds.map((credentialDefinition) => credentialDefinition.cd), - credentialSchemas: scenario.scenario.issuer!.css.map((credentialSchema: any) => credentialSchema.cs), + // Add personas if needed + if (expandSet.has(ShowcaseExpand.PERSONAS)) { + queryConfig.with.personas = { + with: { + persona: { + with: { + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) + ? { + headshotImage: true, + bodyImage: true, + } + : {}), + }, }, - }), - personas: scenario.scenario.personas.map((item) => item.persona), - })), - credentialDefinitions: result.credentialDefinitions.map((item: any) => ({ - ...item.credentialDefinition, - credentialSchema: item.credentialDefinition.cs, - })), - personas: result.personas.map((item) => item.persona), + }, + } + } else { + // Include only the personas join table without expanding the persona entity + queryConfig.with.personas = { + columns: { + persona: true, + }, + } } + return queryConfig } - async findAll(): Promise { - const connection = await this.databaseService.getConnection() - const showcases = await connection.query.showcases.findMany({ - with: { bannerImage: true }, - }) - const showcaseIds = showcases.map((s: any) => s.id) + async findAll(expand?: ShowcaseExpand[]): Promise { + const expandSet = new Set(expand || []) - const [credDefData, scenariosData, personasData] = await Promise.all([ - connection.query.showcasesToCredentialDefinitions.findMany({ - where: inArray(showcasesToCredentialDefinitions.showcase, showcaseIds), + // Define our query structure based on what should be included + let queryConfig: any = { + with: {}, + } + + if (expandSet.has(ShowcaseExpand.ASSET_CONTENT)) { + queryConfig.with.bannerImage = true + } + + // Add credentialDefinitions to query config + if (expandSet.has(ShowcaseExpand.CREDENTIAL_DEFINITIONS)) { + queryConfig.with.credentialDefinitions = { with: { credentialDefinition: { with: { - icon: true, + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) && { icon: true }), cs: { with: { attributes: true, @@ -627,9 +774,18 @@ class ShowcaseRepository implements RepositoryDefinition }, }, }, - }), - connection.query.showcasesToScenarios.findMany({ - where: inArray(showcasesToScenarios.showcase, showcaseIds), + } + } else { + queryConfig.with.credentialDefinitions = { + columns: { + credentialDefinition: true, + }, + } + } + + // Add scenarios to query config + if (expandSet.has(ShowcaseExpand.SCENARIOS)) { + queryConfig.with.scenarios = { with: { scenario: { with: { @@ -640,7 +796,7 @@ class ShowcaseRepository implements RepositoryDefinition proofRequest: true, }, }, - asset: true, + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { asset: true } : {}), }, }, issuer: { @@ -649,7 +805,7 @@ class ShowcaseRepository implements RepositoryDefinition with: { cd: { with: { - icon: true, + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) && { icon: true }), cs: { with: { attributes: true, @@ -670,7 +826,7 @@ class ShowcaseRepository implements RepositoryDefinition }, }, }, - logo: true, + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { logo: true } : {}), }, }, relyingParty: { @@ -679,7 +835,7 @@ class ShowcaseRepository implements RepositoryDefinition with: { cd: { with: { - icon: true, + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) && { icon: true }), cs: { with: { attributes: true, @@ -691,15 +847,19 @@ class ShowcaseRepository implements RepositoryDefinition }, }, }, - logo: true, + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { logo: true } : {}), }, }, personas: { with: { persona: { with: { - headshotImage: true, - bodyImage: true, + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) + ? { + headshotImage: true, + bodyImage: true, + } + : {}), }, }, }, @@ -707,80 +867,60 @@ class ShowcaseRepository implements RepositoryDefinition }, }, }, - }), - connection.query.showcasesToPersonas.findMany({ - where: inArray(showcasesToPersonas.showcase, showcaseIds), + } + } else { + queryConfig.with.scenarios = { + columns: { + scenario: true, + }, + } + } + + // Add personas to query config + if (expandSet.has(ShowcaseExpand.PERSONAS)) { + queryConfig.with.personas = { with: { persona: { with: { - headshotImage: true, - bodyImage: true, + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) + ? { + headshotImage: true, + bodyImage: true, + } + : {}), }, }, }, - }), - ]) - - // Group join records by showcase id - const credDefMap = new Map() - for (const item of credDefData) { - const key = item.showcase - if (!credDefMap.has(key)) { - credDefMap.set(key, []) } - credDefMap.get(key)!.push(item) - } - - const scenariosMap = new Map() - for (const item of scenariosData) { - const key = item.showcase - if (!scenariosMap.has(key)) { - scenariosMap.set(key, []) + } else { + queryConfig.with.personas = { + columns: { + persona: true, + }, } - scenariosMap.get(key)!.push(item) } - const personasMap = new Map() - for (const item of personasData) { - const key = item.showcase - if (!personasMap.has(key)) { - personasMap.set(key, []) - } - personasMap.get(key)!.push(item) + const connection = await this.databaseService.getConnection() + const showcasesResult = await connection.query.showcases.findMany(queryConfig) + + if (showcasesResult.length === 0) { + return [] } - return showcases.map((showcase: any) => { - return { - ...showcase, - scenarios: (scenariosMap.get(showcase.id) || []).map((s: any) => { - const scenarioData = { ...s.scenario } - scenarioData.steps = sortSteps(s.scenario.steps) - if (s.scenario.relyingParty) { - scenarioData.relyingParty = { - ...s.scenario.relyingParty, - credentialDefinitions: s.scenario.relyingParty.cds.map((item: any) => item.cd), - } - } - if (s.scenario.issuer) { - scenarioData.issuer = { - ...s.scenario.issuer, - credentialDefinitions: s.scenario.issuer.cds.map((item: any) => item.cd), - credentialSchemas: s.scenario.issuer.css.map((item: any) => item.cs), - } - } - // TODO check this typing issue at a later point in time - scenarioData.personas = s.scenario.personas.map((p: any) => p.persona) - return scenarioData - }), - credentialDefinitions: (credDefMap.get(showcase.id) || []).map((item: any) => { - return { - ...item.credentialDefinition, - credentialSchema: item.credentialDefinition.cs, - } - // TODO check this typing issue at a later point in time - }), - personas: (personasMap.get(showcase.id) || []).map((item: any) => item.persona), + return showcasesResult.map((result): Showcase => { + // Create a typed showcase result + const showcase: Showcase = { + ...result, + scenarios: [], + credentialDefinitions: [], + personas: [], } + + this.populateScenarios(result, expandSet, showcase) + this.populateCredentialDefs(result, expandSet, showcase) + this.populatePersonas(result, expandSet, showcase) + + return showcase }) } diff --git a/apps/credential-showcase-api-server/src/database/repositories/__tests__/issuer.repository.test.ts b/apps/credential-showcase-api-server/src/database/repositories/__tests__/issuer.repository.test.ts index 756233e..866f75a 100644 --- a/apps/credential-showcase-api-server/src/database/repositories/__tests__/issuer.repository.test.ts +++ b/apps/credential-showcase-api-server/src/database/repositories/__tests__/issuer.repository.test.ts @@ -122,12 +122,13 @@ describe('Database issuer repository tests', (): void => { expect(savedIssuer.description).toEqual(issuer.description) expect(savedIssuer.organization).toEqual(issuer.organization) expect(savedIssuer.credentialDefinitions.length).toEqual(2) - expect(savedIssuer.logo).not.toBeNull() - expect(savedIssuer.logo!.id).toBeDefined() - expect(savedIssuer.logo!.mediaType).toEqual(asset.mediaType) - expect(savedIssuer.logo!.fileName).toEqual(asset.fileName) - expect(savedIssuer.logo!.description).toEqual(asset.description) - expect(savedIssuer.logo!.content).toStrictEqual(asset.content) + const logoAsset = savedIssuer.logo as Asset + expect(logoAsset).not.toBeNull() + expect(logoAsset!.id).toBeDefined() + expect(logoAsset!.mediaType).toEqual(asset.mediaType) + expect(logoAsset!.fileName).toEqual(asset.fileName) + expect(logoAsset!.description).toEqual(asset.description) + expect(logoAsset!.content).toStrictEqual(asset.content) }) it('Should throw error when saving issuer with invalid logo id', async (): Promise => { @@ -210,12 +211,13 @@ describe('Database issuer repository tests', (): void => { expect(fromDb.description).toEqual(issuer.description) expect(fromDb.organization).toEqual(issuer.organization) expect(fromDb.credentialDefinitions.length).toEqual(2) - expect(fromDb.logo).not.toBeNull() - expect(fromDb.logo!.id).toBeDefined() - expect(fromDb.logo!.mediaType).toEqual(asset.mediaType) - expect(fromDb.logo!.fileName).toEqual(asset.fileName) - expect(fromDb.logo!.description).toEqual(asset.description) - expect(fromDb.logo!.content).toStrictEqual(asset.content) + const logoAsset = fromDb.logo as Asset + expect(logoAsset).not.toBeNull() + expect(logoAsset!.id).toBeDefined() + expect(logoAsset!.mediaType).toEqual(asset.mediaType) + expect(logoAsset!.fileName).toEqual(asset.fileName) + expect(logoAsset!.description).toEqual(asset.description) + expect(logoAsset!.content).toStrictEqual(asset.content) }) it('Should get all issuers from database', async (): Promise => { @@ -277,7 +279,7 @@ describe('Database issuer repository tests', (): void => { name: newName, credentialDefinitions: [credentialDefinition1.id], credentialSchemas: [credentialSchema.id], - logo: savedIssuer.logo?.id, + logo: (savedIssuer.logo as Asset)?.id, }) expect(updatedIssuer).toBeDefined() @@ -286,12 +288,13 @@ describe('Database issuer repository tests', (): void => { expect(updatedIssuer.description).toEqual(issuer.description) expect(updatedIssuer.organization).toEqual(issuer.organization) expect(updatedIssuer.credentialDefinitions.length).toEqual(1) - expect(updatedIssuer.logo).not.toBeNull() - expect(updatedIssuer.logo!.id).toBeDefined() - expect(updatedIssuer.logo!.mediaType).toEqual(asset.mediaType) - expect(updatedIssuer.logo!.fileName).toEqual(asset.fileName) - expect(updatedIssuer.logo!.description).toEqual(asset.description) - expect(updatedIssuer.logo!.content).toStrictEqual(asset.content) + const logoAsset = updatedIssuer.logo as Asset + expect(logoAsset).not.toBeNull() + expect(logoAsset!.id).toBeDefined() + expect(logoAsset!.mediaType).toEqual(asset.mediaType) + expect(logoAsset!.fileName).toEqual(asset.fileName) + expect(logoAsset!.description).toEqual(asset.description) + expect(logoAsset!.content).toStrictEqual(asset.content) }) it('Should throw error when updating issuer with invalid logo id', async (): Promise => { diff --git a/apps/credential-showcase-api-server/src/database/repositories/__tests__/persona.repository.test.ts b/apps/credential-showcase-api-server/src/database/repositories/__tests__/persona.repository.test.ts index 0a201cd..3e1d663 100644 --- a/apps/credential-showcase-api-server/src/database/repositories/__tests__/persona.repository.test.ts +++ b/apps/credential-showcase-api-server/src/database/repositories/__tests__/persona.repository.test.ts @@ -58,18 +58,20 @@ describe('Database persona repository tests', (): void => { expect(savedPersona.role).toEqual(persona.role) expect(savedPersona.description).toEqual(persona.description) expect(savedPersona.hidden).toEqual(persona.hidden) - expect(savedPersona.headshotImage).toBeDefined() - expect(savedPersona.headshotImage!.id).toBeDefined() - expect(savedPersona.headshotImage!.mediaType).toEqual(asset.mediaType) - expect(savedPersona.headshotImage!.fileName).toEqual(asset.fileName) - expect(savedPersona.headshotImage!.description).toEqual(asset.description) - expect(savedPersona.headshotImage!.content).toStrictEqual(asset.content) - expect(savedPersona.bodyImage).toBeDefined() - expect(savedPersona.bodyImage!.id).toBeDefined() - expect(savedPersona.bodyImage!.mediaType).toEqual(asset.mediaType) - expect(savedPersona.bodyImage!.fileName).toEqual(asset.fileName) - expect(savedPersona.bodyImage!.description).toEqual(asset.description) - expect(savedPersona.bodyImage!.content).toStrictEqual(asset.content) + const hsAsset = savedPersona.headshotImage as Asset + expect(hsAsset).toBeDefined() + expect(hsAsset!.id).toBeDefined() + expect(hsAsset!.mediaType).toEqual(asset.mediaType) + expect(hsAsset!.fileName).toEqual(asset.fileName) + expect(hsAsset!.description).toEqual(asset.description) + expect(hsAsset!.content).toStrictEqual(asset.content) + const biAsset = savedPersona.bodyImage as Asset + expect(biAsset).toBeDefined() + expect(biAsset!.id).toBeDefined() + expect(biAsset!.mediaType).toEqual(asset.mediaType) + expect(biAsset!.fileName).toEqual(asset.fileName) + expect(biAsset!.description).toEqual(asset.description) + expect(biAsset!.content).toStrictEqual(asset.content) }) it('Should save persona without images to database', async (): Promise => { @@ -135,18 +137,20 @@ describe('Database persona repository tests', (): void => { expect(fromDb.name).toEqual(persona.name) expect(fromDb.role).toEqual(persona.role) expect(fromDb.description).toEqual(persona.description) - expect(fromDb.headshotImage).toBeDefined() - expect(fromDb.headshotImage!.id).toBeDefined() - expect(fromDb.headshotImage!.mediaType).toEqual(asset.mediaType) - expect(fromDb.headshotImage!.fileName).toEqual(asset.fileName) - expect(fromDb.headshotImage!.description).toEqual(asset.description) - expect(fromDb.headshotImage!.content).toStrictEqual(asset.content) - expect(fromDb.bodyImage).toBeDefined() - expect(fromDb.bodyImage!.id).toBeDefined() - expect(fromDb.bodyImage!.mediaType).toEqual(asset.mediaType) - expect(fromDb.bodyImage!.fileName).toEqual(asset.fileName) - expect(fromDb.bodyImage!.description).toEqual(asset.description) - expect(fromDb.bodyImage!.content).toStrictEqual(asset.content) + const hsAsset = fromDb.headshotImage as Asset + expect(hsAsset).toBeDefined() + expect(hsAsset!.id).toBeDefined() + expect(hsAsset!.mediaType).toEqual(asset.mediaType) + expect(hsAsset!.fileName).toEqual(asset.fileName) + expect(hsAsset!.description).toEqual(asset.description) + expect(hsAsset!.content).toStrictEqual(asset.content) + const biAsset = fromDb.bodyImage as Asset + expect(biAsset).toBeDefined() + expect(biAsset!.id).toBeDefined() + expect(biAsset!.mediaType).toEqual(asset.mediaType) + expect(biAsset!.fileName).toEqual(asset.fileName) + expect(biAsset!.description).toEqual(asset.description) + expect(biAsset!.content).toStrictEqual(asset.content) }) it('Should get all personas from database', async (): Promise => { @@ -204,8 +208,8 @@ describe('Database persona repository tests', (): void => { const newName = 'Jane Doe' const updatedPersona = await personaRepository.update(savedPersona.id, { ...savedPersona, - headshotImage: savedPersona.headshotImage!.id, - bodyImage: savedPersona.bodyImage!.id, + headshotImage: (savedPersona.headshotImage as Asset)!.id, + bodyImage: (savedPersona.bodyImage as Asset)!.id, name: newName, }) @@ -215,18 +219,20 @@ describe('Database persona repository tests', (): void => { expect(updatedPersona.role).toEqual(persona.role) expect(updatedPersona.description).toEqual(persona.description) expect(updatedPersona.hidden).toEqual(persona.hidden) - expect(updatedPersona.headshotImage).toBeDefined() - expect(updatedPersona.headshotImage!.id).toBeDefined() - expect(updatedPersona.headshotImage!.mediaType).toEqual(asset.mediaType) - expect(updatedPersona.headshotImage!.fileName).toEqual(asset.fileName) - expect(updatedPersona.headshotImage!.description).toEqual(asset.description) - expect(updatedPersona.headshotImage!.content).toStrictEqual(asset.content) - expect(updatedPersona.bodyImage).toBeDefined() - expect(updatedPersona.bodyImage!.id).toBeDefined() - expect(updatedPersona.bodyImage!.mediaType).toEqual(asset.mediaType) - expect(updatedPersona.bodyImage!.fileName).toEqual(asset.fileName) - expect(updatedPersona.bodyImage!.description).toEqual(asset.description) - expect(updatedPersona.bodyImage!.content).toStrictEqual(asset.content) + const hsAsset = updatedPersona.headshotImage as Asset + expect(hsAsset).toBeDefined() + expect(hsAsset!.id).toBeDefined() + expect(hsAsset!.mediaType).toEqual(asset.mediaType) + expect(hsAsset!.fileName).toEqual(asset.fileName) + expect(hsAsset!.description).toEqual(asset.description) + expect(hsAsset!.content).toStrictEqual(asset.content) + const biAsset = updatedPersona.bodyImage as Asset + expect(biAsset).toBeDefined() + expect(biAsset!.id).toBeDefined() + expect(biAsset!.mediaType).toEqual(asset.mediaType) + expect(biAsset!.fileName).toEqual(asset.fileName) + expect(biAsset!.description).toEqual(asset.description) + expect(biAsset!.content).toStrictEqual(asset.content) }) it('Should throw error when updating persona with invalid headshot image id', async (): Promise => { @@ -246,7 +252,7 @@ describe('Database persona repository tests', (): void => { const updatedPersona: NewPersona = { ...savedPersona, headshotImage: unknownImageId, - bodyImage: savedPersona.bodyImage!.id, + bodyImage: (savedPersona.bodyImage as Asset)!.id, } await expect(personaRepository.update(savedPersona.id, updatedPersona)).rejects.toThrowError(`No asset found for id: ${unknownImageId}`) @@ -268,7 +274,7 @@ describe('Database persona repository tests', (): void => { const updatedPersona: NewPersona = { ...savedPersona, - headshotImage: savedPersona.headshotImage!.id, + headshotImage: (savedPersona.headshotImage as Asset).id, bodyImage: unknownImageId, } diff --git a/apps/credential-showcase-api-server/src/database/repositories/__tests__/relyingParty.repository.test.ts b/apps/credential-showcase-api-server/src/database/repositories/__tests__/relyingParty.repository.test.ts index 37c30f7..5099a9d 100644 --- a/apps/credential-showcase-api-server/src/database/repositories/__tests__/relyingParty.repository.test.ts +++ b/apps/credential-showcase-api-server/src/database/repositories/__tests__/relyingParty.repository.test.ts @@ -13,15 +13,15 @@ import * as schema from '../../schema' import { Asset, CredentialAttributeType, - CredentialType, CredentialDefinition, + CredentialSchema, + CredentialType, + IdentifierType, NewAsset, NewCredentialDefinition, + NewCredentialSchema, NewRelyingParty, RelyingPartyType, - NewCredentialSchema, - IdentifierType, - CredentialSchema, } from '../../../types' describe('Database relying party repository tests', (): void => { @@ -122,12 +122,13 @@ describe('Database relying party repository tests', (): void => { expect(savedRelyingParty.description).toEqual(relyingParty.description) expect(savedRelyingParty.organization).toEqual(relyingParty.organization) expect(savedRelyingParty.credentialDefinitions.length).toEqual(2) - expect(savedRelyingParty.logo).not.toBeNull() - expect(savedRelyingParty.logo!.id).toBeDefined() - expect(savedRelyingParty.logo!.mediaType).toEqual(asset.mediaType) - expect(savedRelyingParty.logo!.fileName).toEqual(asset.fileName) - expect(savedRelyingParty.logo!.description).toEqual(asset.description) - expect(savedRelyingParty.logo!.content).toStrictEqual(asset.content) + const logoAsset = savedRelyingParty.logo as Asset + expect(logoAsset).not.toBeNull() + expect(logoAsset!.id).toBeDefined() + expect(logoAsset!.mediaType).toEqual(logoAsset.mediaType) + expect(logoAsset!.fileName).toEqual(logoAsset.fileName) + expect(logoAsset!.description).toEqual(logoAsset.description) + expect(logoAsset!.content).toStrictEqual(logoAsset.content) }) it('Should throw error when saving relying party with invalid logo id', async (): Promise => { @@ -192,12 +193,13 @@ describe('Database relying party repository tests', (): void => { expect(fromDb.description).toEqual(relyingParty.description) expect(fromDb.organization).toEqual(relyingParty.organization) expect(fromDb.credentialDefinitions.length).toEqual(2) - expect(fromDb.logo).not.toBeNull() - expect(fromDb.logo!.id).toBeDefined() - expect(fromDb.logo!.mediaType).toEqual(asset.mediaType) - expect(fromDb.logo!.fileName).toEqual(asset.fileName) - expect(fromDb.logo!.description).toEqual(asset.description) - expect(fromDb.logo!.content).toStrictEqual(asset.content) + const logoAsset = fromDb.logo as Asset + expect(logoAsset).not.toBeNull() + expect(logoAsset!.id).toBeDefined() + expect(logoAsset!.mediaType).toEqual(logoAsset.mediaType) + expect(logoAsset!.fileName).toEqual(logoAsset.fileName) + expect(logoAsset!.description).toEqual(logoAsset.description) + expect(logoAsset!.content).toStrictEqual(logoAsset.content) }) it('Should get all relying parties from database', async (): Promise => { @@ -255,7 +257,7 @@ describe('Database relying party repository tests', (): void => { ...savedRelyingParty, name: newName, credentialDefinitions: [credentialDefinition1.id], - logo: savedRelyingParty.logo?.id, + logo: (savedRelyingParty.logo as Asset)?.id, }) expect(updatedRelyingParty).toBeDefined() @@ -264,12 +266,13 @@ describe('Database relying party repository tests', (): void => { expect(updatedRelyingParty.description).toEqual(relyingParty.description) expect(updatedRelyingParty.organization).toEqual(relyingParty.organization) expect(updatedRelyingParty.credentialDefinitions.length).toEqual(1) - expect(updatedRelyingParty.logo).not.toBeNull() - expect(updatedRelyingParty.logo!.id).toBeDefined() - expect(updatedRelyingParty.logo!.mediaType).toEqual(asset.mediaType) - expect(updatedRelyingParty.logo!.fileName).toEqual(asset.fileName) - expect(updatedRelyingParty.logo!.description).toEqual(asset.description) - expect(updatedRelyingParty.logo!.content).toStrictEqual(asset.content) + const logoAsset = updatedRelyingParty.logo as Asset + expect(logoAsset).not.toBeNull() + expect(logoAsset!.id).toBeDefined() + expect(logoAsset!.mediaType).toEqual(logoAsset.mediaType) + expect(logoAsset!.fileName).toEqual(logoAsset.fileName) + expect(logoAsset!.description).toEqual(logoAsset.description) + expect(logoAsset!.content).toStrictEqual(logoAsset.content) }) it('Should throw error when updating relying party with invalid logo id', async (): Promise => { diff --git a/apps/credential-showcase-api-server/src/database/repositories/__tests__/scenario.repository.test.ts b/apps/credential-showcase-api-server/src/database/repositories/__tests__/scenario.repository.test.ts index 8004b45..289b117 100644 --- a/apps/credential-showcase-api-server/src/database/repositories/__tests__/scenario.repository.test.ts +++ b/apps/credential-showcase-api-server/src/database/repositories/__tests__/scenario.repository.test.ts @@ -278,11 +278,12 @@ describe('Database scenario repository tests', (): void => { issuanceScenario.steps[0].actions[0].proofRequest!.predicates.predicate1.value, ) expect(savedIssuanceScenario.steps[0].actions[0].proofRequest!.predicates!.predicate1.restrictions!.length).toEqual(2) - expect(savedIssuanceScenario.steps[0].asset).not.toBeNull() - expect(savedIssuanceScenario.steps[0].asset!.mediaType).toEqual(asset.mediaType) - expect(savedIssuanceScenario.steps[0].asset!.fileName).toEqual(asset.fileName) - expect(savedIssuanceScenario.steps[0].asset!.description).toEqual(asset.description) - expect(savedIssuanceScenario.steps[0].asset!.content).toStrictEqual(asset.content) + const stepAsset = savedIssuanceScenario.steps[0].asset as Asset + expect(stepAsset).not.toBeNull() + expect(stepAsset!.mediaType).toEqual(asset.mediaType) + expect(stepAsset!.fileName).toEqual(asset.fileName) + expect(stepAsset!.description).toEqual(asset.description) + expect(stepAsset!.content).toStrictEqual(asset.content) expect((savedIssuanceScenario).issuer).not.toBeNull() expect((savedIssuanceScenario).issuer!.name).toEqual(issuer.name) expect((savedIssuanceScenario).issuer!.credentialDefinitions.length).toEqual(1) @@ -294,23 +295,26 @@ describe('Database scenario repository tests', (): void => { expect(savedIssuanceScenario.personas[0].name).toEqual(persona1.name) expect(savedIssuanceScenario.personas[0].role).toEqual(persona1.role) expect(savedIssuanceScenario.personas[0].description).toEqual(persona1.description) - expect(savedIssuanceScenario.personas[0].headshotImage).not.toBeNull() - expect(savedIssuanceScenario.personas[0].headshotImage!.id).toBeDefined() - expect(savedIssuanceScenario.personas[0].headshotImage!.mediaType).toEqual(asset.mediaType) - expect(savedIssuanceScenario.personas[0].headshotImage!.fileName).toEqual(asset.fileName) - expect(savedIssuanceScenario.personas[0].headshotImage!.description).toEqual(asset.description) - expect(savedIssuanceScenario.personas[0].headshotImage!.content).toStrictEqual(asset.content) - expect(savedIssuanceScenario.personas[0].bodyImage).not.toBeNull() - expect(savedIssuanceScenario.personas[0].bodyImage!.id).toBeDefined() - expect(savedIssuanceScenario.personas[0].bodyImage!.mediaType).toEqual(asset.mediaType) - expect(savedIssuanceScenario.personas[0].bodyImage!.fileName).toEqual(asset.fileName) - expect(savedIssuanceScenario.personas[0].bodyImage!.description).toEqual(asset.description) - expect(savedIssuanceScenario.personas[0].bodyImage!.content).toStrictEqual(asset.content) - expect(savedIssuanceScenario.bannerImage!.id).toBeDefined() - expect(savedIssuanceScenario.bannerImage!.mediaType).toEqual(asset.mediaType) - expect(savedIssuanceScenario.bannerImage!.fileName).toEqual(asset.fileName) - expect(savedIssuanceScenario.bannerImage!.description).toEqual(asset.description) - expect(savedIssuanceScenario.bannerImage!.content).toStrictEqual(asset.content) + const hsAsset = savedIssuanceScenario.personas[0].headshotImage as Asset + expect(hsAsset).not.toBeNull() + expect(hsAsset!.id).toBeDefined() + expect(hsAsset!.mediaType).toEqual(asset.mediaType) + expect(hsAsset!.fileName).toEqual(asset.fileName) + expect(hsAsset!.description).toEqual(asset.description) + expect(hsAsset!.content).toStrictEqual(asset.content) + const biAsset = savedIssuanceScenario.personas[0].bodyImage as Asset + expect(biAsset).not.toBeNull() + expect(biAsset!.id).toBeDefined() + expect(biAsset!.mediaType).toEqual(asset.mediaType) + expect(biAsset!.fileName).toEqual(asset.fileName) + expect(biAsset!.description).toEqual(asset.description) + expect(biAsset!.content).toStrictEqual(asset.content) + const bnAsset = savedIssuanceScenario.bannerImage as Asset + expect(bnAsset!.id).toBeDefined() + expect(bnAsset!.mediaType).toEqual(asset.mediaType) + expect(bnAsset!.fileName).toEqual(asset.fileName) + expect(bnAsset!.description).toEqual(asset.description) + expect(bnAsset!.content).toStrictEqual(asset.content) }) it('Should save presentation scenario to database', async (): Promise => { @@ -421,11 +425,12 @@ describe('Database scenario repository tests', (): void => { expect(savedPresentationScenario.steps[0].actions[0].title).toEqual(presentationScenario.steps[0].actions[0].title) expect(savedPresentationScenario.steps[0].actions[0].actionType).toEqual(presentationScenario.steps[0].actions[0].actionType) expect(savedPresentationScenario.steps[0].actions[0].text).toEqual(presentationScenario.steps[0].actions[0].text) - expect(savedPresentationScenario.steps[0].asset).not.toBeNull() - expect(savedPresentationScenario.steps[0].asset!.mediaType).toEqual(asset.mediaType) - expect(savedPresentationScenario.steps[0].asset!.fileName).toEqual(asset.fileName) - expect(savedPresentationScenario.steps[0].asset!.description).toEqual(asset.description) - expect(savedPresentationScenario.steps[0].asset!.content).toStrictEqual(asset.content) + const stepAsset = savedPresentationScenario.steps[0].asset as Asset + expect(stepAsset).not.toBeNull() + expect(stepAsset!.mediaType).toEqual(asset.mediaType) + expect(stepAsset!.fileName).toEqual(asset.fileName) + expect(stepAsset!.description).toEqual(asset.description) + expect(stepAsset!.content).toStrictEqual(asset.content) expect((savedPresentationScenario).relyingParty).not.toBeNull() expect((savedPresentationScenario).relyingParty!.name).toEqual(relyingParty.name) expect((savedPresentationScenario).relyingParty!.credentialDefinitions.length).toEqual(1) @@ -437,23 +442,26 @@ describe('Database scenario repository tests', (): void => { expect(savedPresentationScenario.personas[0].name).toEqual(persona1.name) expect(savedPresentationScenario.personas[0].role).toEqual(persona1.role) expect(savedPresentationScenario.personas[0].description).toEqual(persona1.description) - expect(savedPresentationScenario.personas[0].headshotImage).not.toBeNull() - expect(savedPresentationScenario.personas[0].headshotImage!.id).toBeDefined() - expect(savedPresentationScenario.personas[0].headshotImage!.mediaType).toEqual(asset.mediaType) - expect(savedPresentationScenario.personas[0].headshotImage!.fileName).toEqual(asset.fileName) - expect(savedPresentationScenario.personas[0].headshotImage!.description).toEqual(asset.description) - expect(savedPresentationScenario.personas[0].headshotImage!.content).toStrictEqual(asset.content) - expect(savedPresentationScenario.personas[0].bodyImage).not.toBeNull() - expect(savedPresentationScenario.personas[0].bodyImage!.id).toBeDefined() - expect(savedPresentationScenario.personas[0].bodyImage!.mediaType).toEqual(asset.mediaType) - expect(savedPresentationScenario.personas[0].bodyImage!.fileName).toEqual(asset.fileName) - expect(savedPresentationScenario.personas[0].bodyImage!.description).toEqual(asset.description) - expect(savedPresentationScenario.personas[0].bodyImage!.content).toStrictEqual(asset.content) - expect(savedPresentationScenario.bannerImage!.id).toBeDefined() - expect(savedPresentationScenario.bannerImage!.mediaType).toEqual(asset.mediaType) - expect(savedPresentationScenario.bannerImage!.fileName).toEqual(asset.fileName) - expect(savedPresentationScenario.bannerImage!.description).toEqual(asset.description) - expect(savedPresentationScenario.bannerImage!.content).toStrictEqual(asset.content) + const hsAsset = savedPresentationScenario.personas[0].headshotImage as Asset + expect(hsAsset).not.toBeNull() + expect(hsAsset!.id).toBeDefined() + expect(hsAsset!.mediaType).toEqual(asset.mediaType) + expect(hsAsset!.fileName).toEqual(asset.fileName) + expect(hsAsset!.description).toEqual(asset.description) + expect(hsAsset!.content).toStrictEqual(asset.content) + const iAsset = savedPresentationScenario.personas[0].bodyImage as Asset + expect(iAsset).not.toBeNull() + expect(iAsset!.id).toBeDefined() + expect(iAsset!.mediaType).toEqual(asset.mediaType) + expect(iAsset!.fileName).toEqual(asset.fileName) + expect(iAsset!.description).toEqual(asset.description) + expect(iAsset!.content).toStrictEqual(asset.content) + const bnAsset = savedPresentationScenario.bannerImage as Asset + expect(bnAsset!.id).toBeDefined() + expect(bnAsset!.mediaType).toEqual(asset.mediaType) + expect(bnAsset!.fileName).toEqual(asset.fileName) + expect(bnAsset!.description).toEqual(asset.description) + expect(bnAsset!.content).toStrictEqual(asset.content) }) it('Should throw error when saving scenario with no steps', async (): Promise => { @@ -989,18 +997,20 @@ describe('Database scenario repository tests', (): void => { expect(fromDb.personas[0].name).toEqual(persona1.name) expect(fromDb.personas[0].role).toEqual(persona1.role) expect(fromDb.personas[0].description).toEqual(persona1.description) - expect(fromDb.personas[0].headshotImage).not.toBeNull() - expect(fromDb.personas[0].headshotImage!.id).toBeDefined() - expect(fromDb.personas[0].headshotImage!.mediaType).toEqual(asset.mediaType) - expect(fromDb.personas[0].headshotImage!.fileName).toEqual(asset.fileName) - expect(fromDb.personas[0].headshotImage!.description).toEqual(asset.description) - expect(fromDb.personas[0].headshotImage!.content).toStrictEqual(asset.content) - expect(fromDb.personas[0].bodyImage).not.toBeNull() - expect(fromDb.personas[0].bodyImage!.id).toBeDefined() - expect(fromDb.personas[0].bodyImage!.mediaType).toEqual(asset.mediaType) - expect(fromDb.personas[0].bodyImage!.fileName).toEqual(asset.fileName) - expect(fromDb.personas[0].bodyImage!.description).toEqual(asset.description) - expect(fromDb.personas[0].bodyImage!.content).toStrictEqual(asset.content) + const hsAsset = fromDb.personas[0].headshotImage as Asset + expect(hsAsset).not.toBeNull() + expect(hsAsset!.id).toBeDefined() + expect(hsAsset!.mediaType).toEqual(asset.mediaType) + expect(hsAsset!.fileName).toEqual(asset.fileName) + expect(hsAsset!.description).toEqual(asset.description) + expect(hsAsset!.content).toStrictEqual(asset.content) + const biAsset = fromDb.personas[0].bodyImage as Asset + expect(biAsset).not.toBeNull() + expect(biAsset!.id).toBeDefined() + expect(biAsset!.mediaType).toEqual(asset.mediaType) + expect(biAsset!.fileName).toEqual(asset.fileName) + expect(biAsset!.description).toEqual(asset.description) + expect(biAsset!.content).toStrictEqual(asset.content) }) it('Should get all scenarios from database', async (): Promise => { @@ -1395,11 +1405,12 @@ describe('Database scenario repository tests', (): void => { expect(updatedIssuanceScenarioResult.steps[0].actions[0].title).toEqual(updatedIssuanceScenario.steps[0].actions[0].title) expect(updatedIssuanceScenarioResult.steps[0].actions[0].actionType).toEqual(updatedIssuanceScenario.steps[0].actions[0].actionType) expect(updatedIssuanceScenarioResult.steps[0].actions[0].text).toEqual(updatedIssuanceScenario.steps[0].actions[0].text) - expect(updatedIssuanceScenarioResult.steps[0].asset).not.toBeNull() - expect(updatedIssuanceScenarioResult.steps[0].asset!.mediaType).toEqual(asset.mediaType) - expect(updatedIssuanceScenarioResult.steps[0].asset!.fileName).toEqual(asset.fileName) - expect(updatedIssuanceScenarioResult.steps[0].asset!.description).toEqual(asset.description) - expect(updatedIssuanceScenarioResult.steps[0].asset!.content).toStrictEqual(asset.content) + const stepAsset = updatedIssuanceScenarioResult.steps[0].asset as Asset + expect(stepAsset).not.toBeNull() + expect(stepAsset!.mediaType).toEqual(asset.mediaType) + expect(stepAsset!.fileName).toEqual(asset.fileName) + expect(stepAsset!.description).toEqual(asset.description) + expect(stepAsset!.content).toStrictEqual(asset.content) expect(updatedIssuanceScenarioResult.steps[0].actions[0].proofRequest).not.toBeNull() expect(updatedIssuanceScenarioResult.steps[0].actions[0].proofRequest!.attributes).not.toBeNull() expect(updatedIssuanceScenarioResult.steps[0].actions[0].proofRequest!.attributes!.attribute1).toBeDefined() @@ -1422,18 +1433,20 @@ describe('Database scenario repository tests', (): void => { expect(updatedIssuanceScenarioResult.personas[0].name).toEqual(persona1.name) expect(updatedIssuanceScenarioResult.personas[0].role).toEqual(persona1.role) expect(updatedIssuanceScenarioResult.personas[0].description).toEqual(persona1.description) - expect(updatedIssuanceScenarioResult.personas[0].headshotImage).not.toBeNull() - expect(updatedIssuanceScenarioResult.personas[0].headshotImage!.id).toBeDefined() - expect(updatedIssuanceScenarioResult.personas[0].headshotImage!.mediaType).toEqual(asset.mediaType) - expect(updatedIssuanceScenarioResult.personas[0].headshotImage!.fileName).toEqual(asset.fileName) - expect(updatedIssuanceScenarioResult.personas[0].headshotImage!.description).toEqual(asset.description) - expect(updatedIssuanceScenarioResult.personas[0].headshotImage!.content).toStrictEqual(asset.content) - expect(updatedIssuanceScenarioResult.personas[0].bodyImage).not.toBeNull() - expect(updatedIssuanceScenarioResult.personas[0].bodyImage!.id).toBeDefined() - expect(updatedIssuanceScenarioResult.personas[0].bodyImage!.mediaType).toEqual(asset.mediaType) - expect(updatedIssuanceScenarioResult.personas[0].bodyImage!.fileName).toEqual(asset.fileName) - expect(updatedIssuanceScenarioResult.personas[0].bodyImage!.description).toEqual(asset.description) - expect(updatedIssuanceScenarioResult.personas[0].bodyImage!.content).toStrictEqual(asset.content) + const hsAsset = updatedIssuanceScenarioResult.personas[0].headshotImage as Asset + expect(hsAsset).not.toBeNull() + expect(hsAsset!.id).toBeDefined() + expect(hsAsset!.mediaType).toEqual(asset.mediaType) + expect(hsAsset!.fileName).toEqual(asset.fileName) + expect(hsAsset!.description).toEqual(asset.description) + expect(hsAsset!.content).toStrictEqual(asset.content) + const biAsset = updatedIssuanceScenarioResult.personas[0].bodyImage as Asset + expect(biAsset).not.toBeNull() + expect(biAsset!.id).toBeDefined() + expect(biAsset!.mediaType).toEqual(asset.mediaType) + expect(biAsset!.fileName).toEqual(asset.fileName) + expect(biAsset!.description).toEqual(asset.description) + expect(biAsset!.content).toStrictEqual(asset.content) }) it('Should throw error when updating scenario with no steps', async (): Promise => { @@ -2195,11 +2208,12 @@ describe('Database scenario repository tests', (): void => { expect(fromDb.steps[1].actions[0].title).toEqual(step.actions[0].title) expect(fromDb.steps[1].actions[0].actionType).toEqual(step.actions[0].actionType) expect(fromDb.steps[1].actions[0].text).toEqual(step.actions[0].text) - expect(fromDb.steps[1].asset).not.toBeNull() - expect(fromDb.steps[1].asset!.mediaType).toEqual(asset.mediaType) - expect(fromDb.steps[1].asset!.fileName).toEqual(asset.fileName) - expect(fromDb.steps[1].asset!.description).toEqual(asset.description) - expect(fromDb.steps[1].asset!.content).toStrictEqual(asset.content) + const stepAsset = fromDb.steps[1].asset as Asset + expect(stepAsset).not.toBeNull() + expect(stepAsset!.mediaType).toEqual(asset.mediaType) + expect(stepAsset!.fileName).toEqual(asset.fileName) + expect(stepAsset!.description).toEqual(asset.description) + expect(stepAsset!.content).toStrictEqual(asset.content) expect(fromDb.steps[1].actions[0].proofRequest).not.toBeNull() expect(fromDb.steps[1].actions[0].proofRequest!.attributes).not.toBeNull() expect(fromDb.steps[1].actions[0].proofRequest!.attributes!.attribute1).toBeDefined() @@ -2382,11 +2396,12 @@ describe('Database scenario repository tests', (): void => { expect(fromDb.actions[0].title).toEqual(issuanceScenario.steps[0].actions[0].title) expect(fromDb.actions[0].actionType).toEqual(issuanceScenario.steps[0].actions[0].actionType) expect(fromDb.actions[0].text).toEqual(issuanceScenario.steps[0].actions[0].text) - expect(fromDb.asset).not.toBeNull() - expect(fromDb.asset!.mediaType).toEqual(asset.mediaType) - expect(fromDb.asset!.fileName).toEqual(asset.fileName) - expect(fromDb.asset!.description).toEqual(asset.description) - expect(fromDb.asset!.content).toStrictEqual(asset.content) + const dbAsset = fromDb.asset as Asset + expect(dbAsset).not.toBeNull() + expect(dbAsset!.mediaType).toEqual(asset.mediaType) + expect(dbAsset!.fileName).toEqual(asset.fileName) + expect(dbAsset!.description).toEqual(asset.description) + expect(dbAsset!.content).toStrictEqual(asset.content) expect(fromDb.actions[0].proofRequest).not.toBeNull() expect(fromDb.actions[0].proofRequest!.attributes).not.toBeNull() expect(fromDb.actions[0].proofRequest!.attributes!.attribute1).toBeDefined() @@ -2513,11 +2528,12 @@ describe('Database scenario repository tests', (): void => { expect(fromDb[0].actions[0].title).toEqual(issuanceScenario.steps[0].actions[0].title) expect(fromDb[0].actions[0].actionType).toEqual(issuanceScenario.steps[0].actions[0].actionType) expect(fromDb[0].actions[0].text).toEqual(issuanceScenario.steps[0].actions[0].text) - expect(fromDb[0].asset).not.toBeNull() - expect(fromDb[0].asset!.mediaType).toEqual(asset.mediaType) - expect(fromDb[0].asset!.fileName).toEqual(asset.fileName) - expect(fromDb[0].asset!.description).toEqual(asset.description) - expect(fromDb[0].asset!.content).toStrictEqual(asset.content) + const dbAsset = fromDb[0].asset as Asset + expect(dbAsset).not.toBeNull() + expect(dbAsset!.mediaType).toEqual(asset.mediaType) + expect(dbAsset!.fileName).toEqual(asset.fileName) + expect(dbAsset!.description).toEqual(asset.description) + expect(dbAsset!.content).toStrictEqual(asset.content) }) it('Should delete scenario step from database', async (): Promise => { @@ -2744,7 +2760,7 @@ describe('Database scenario repository tests', (): void => { }, }, ], - asset: savedIssuanceScenario.steps[0].asset!.id, + asset: (savedIssuanceScenario.steps[0].asset as Asset)!.id, } const updatedStepResult = await repository.updateStep(savedIssuanceScenario.id, savedIssuanceScenario.steps[0].id, updatedStep) @@ -2757,11 +2773,12 @@ describe('Database scenario repository tests', (): void => { expect(updatedStepResult.actions[0].title).toEqual(updatedStep.actions[0].title) expect(updatedStepResult.actions[0].actionType).toEqual(updatedStep.actions[0].actionType) expect(updatedStepResult.actions[0].text).toEqual(updatedStep.actions[0].text) - expect(updatedStepResult.asset).not.toBeNull() - expect(updatedStepResult.asset!.mediaType).toEqual(asset.mediaType) - expect(updatedStepResult.asset!.fileName).toEqual(asset.fileName) - expect(updatedStepResult.asset!.description).toEqual(asset.description) - expect(updatedStepResult.asset!.content).toStrictEqual(asset.content) + const updAsset = updatedStepResult.asset as Asset + expect(updAsset).not.toBeNull() + expect(updAsset!.mediaType).toEqual(asset.mediaType) + expect(updAsset!.fileName).toEqual(asset.fileName) + expect(updAsset!.description).toEqual(asset.description) + expect(updAsset!.content).toStrictEqual(asset.content) expect(updatedStepResult.actions[0].proofRequest).not.toBeNull() expect(updatedStepResult.actions[0].proofRequest!.attributes).not.toBeNull() expect(updatedStepResult.actions[0].proofRequest!.attributes!.attribute1).toBeDefined() @@ -2838,7 +2855,7 @@ describe('Database scenario repository tests', (): void => { const updatedStep: NewStep = { ...savedIssuanceScenario.steps[0], actions: [], - asset: savedIssuanceScenario.steps[0].asset!.id, + asset: (savedIssuanceScenario.steps[0].asset as Asset)!.id, } await expect(repository.updateStep(savedIssuanceScenario.id, savedIssuanceScenario.steps[0].id, updatedStep)).rejects.toThrowError( diff --git a/apps/credential-showcase-api-server/src/database/repositories/__tests__/showcase.repository.test.ts b/apps/credential-showcase-api-server/src/database/repositories/__tests__/showcase.repository.test.ts index 0c71386..fa195fb 100644 --- a/apps/credential-showcase-api-server/src/database/repositories/__tests__/showcase.repository.test.ts +++ b/apps/credential-showcase-api-server/src/database/repositories/__tests__/showcase.repository.test.ts @@ -29,6 +29,7 @@ import { NewPersona, NewShowcase, Persona, + ShowcaseExpand, ShowcaseStatus, StepActionType, StepType, @@ -254,11 +255,18 @@ describe('Database showcase repository tests', (): void => { expect(savedShowcase.scenarios.length).toEqual(2) expect(savedShowcase.credentialDefinitions.length).toEqual(2) expect(savedShowcase.personas.length).toEqual(2) - expect(savedShowcase.bannerImage!.id).toBeDefined() - expect(savedShowcase.bannerImage!.mediaType).toEqual(asset.mediaType) - expect(savedShowcase.bannerImage!.fileName).toEqual(asset.fileName) - expect(savedShowcase.bannerImage!.description).toEqual(asset.description) - expect(savedShowcase.bannerImage!.content).toStrictEqual(asset.content) + + // Check banner image + expect(savedShowcase.bannerImage).toBeDefined() + if (!savedShowcase.bannerImage || typeof savedShowcase.bannerImage !== 'object') { + throw Error('expected fromDb.bannerImage to be an asset object') + } + + expect(savedShowcase.bannerImage.id).toBeDefined() + expect(savedShowcase.bannerImage.mediaType).toEqual(asset.mediaType) + expect(savedShowcase.bannerImage.fileName).toEqual(asset.fileName) + expect(savedShowcase.bannerImage.description).toEqual(asset.description) + expect(savedShowcase.bannerImage.content).toStrictEqual(asset.content) }) it('Should throw error when saving showcase with no personas', async (): Promise => { @@ -364,7 +372,38 @@ describe('Database showcase repository tests', (): void => { await expect(repository.create(showcase)).rejects.toThrowError(`No scenario found for id: ${unknownScenarioId}`) }) - it('Should get showcase by id from database', async (): Promise => { + it('Should get showcase by id from database with no expands', async (): Promise => { + const showcase: NewShowcase = { + name: 'example_name', + description: 'example_description', + status: ShowcaseStatus.ACTIVE, + hidden: false, + scenarios: [issuanceScenario1.id, issuanceScenario2.id], + credentialDefinitions: [credentialDefinition1.id, credentialDefinition2.id], + personas: [persona1.id, persona2.id], + } + + const savedShowcase = await repository.create(showcase) + expect(savedShowcase).toBeDefined() + + // Get showcase with no expands + const fromDb = await repository.findById(savedShowcase.id, []) + + expect(fromDb).toBeDefined() + expect(fromDb.name).toEqual(showcase.name) + expect(fromDb.description).toEqual(showcase.description) + expect(fromDb.status).toEqual(showcase.status) + expect(fromDb.hidden).toEqual(showcase.hidden) + expect(fromDb.scenarios.length).toBeGreaterThan(0) + expect(fromDb.scenarios[0]).toBe(issuanceScenario1.id) + expect(fromDb.credentialDefinitions.length).toBeGreaterThan(0) + expect(fromDb.credentialDefinitions[0]).toBe(credentialDefinition1.id) + expect(fromDb.personas.length).toBeGreaterThan(0) + expect(fromDb.personas[0]).toBe(persona1.id) + expect(fromDb.bannerImage).toBeNull() // bannerImage is null when not expanded + }) + + it('Should get showcase by id from database with all expands including asset content', async (): Promise => { const showcase: NewShowcase = { name: 'example_name', description: 'example_description', @@ -373,12 +412,19 @@ describe('Database showcase repository tests', (): void => { scenarios: [issuanceScenario1.id, issuanceScenario2.id], credentialDefinitions: [credentialDefinition1.id, credentialDefinition2.id], personas: [persona1.id, persona2.id], + bannerImage: asset.id, } const savedShowcase = await repository.create(showcase) expect(savedShowcase).toBeDefined() - const fromDb = await repository.findById(savedShowcase.id) + // Get showcase with all expands including asset content + const fromDb = await repository.findById(savedShowcase.id, [ + ShowcaseExpand.SCENARIOS, + ShowcaseExpand.CREDENTIAL_DEFINITIONS, + ShowcaseExpand.PERSONAS, + ShowcaseExpand.ASSET_CONTENT, + ]) expect(fromDb).toBeDefined() expect(fromDb.name).toEqual(showcase.name) @@ -388,9 +434,75 @@ describe('Database showcase repository tests', (): void => { expect(fromDb.scenarios.length).toEqual(2) expect(fromDb.credentialDefinitions.length).toEqual(2) expect(fromDb.personas.length).toEqual(2) + + // Check that bannerImage is an object with content + expect(fromDb.bannerImage).toBeDefined() + if (!fromDb.bannerImage || typeof fromDb.bannerImage !== 'object') { + throw Error('expected fromDb.bannerImage to be an asset object') + } + expect(fromDb.bannerImage.id).toBeDefined() + expect(fromDb.bannerImage.mediaType).toEqual(asset.mediaType) + expect(fromDb.bannerImage.fileName).toEqual(asset.fileName) + expect(fromDb.bannerImage.description).toEqual(asset.description) + expect(fromDb.bannerImage.content).toBeDefined() + expect(Buffer.isBuffer(fromDb.bannerImage.content)).toBeTruthy() }) - it('Should get all showcases from database', async (): Promise => { + it('Should get showcase by id with relations expanded but without asset content', async (): Promise => { + const showcase: NewShowcase = { + name: 'example_name', + description: 'example_description', + status: ShowcaseStatus.ACTIVE, + hidden: false, + scenarios: [issuanceScenario1.id, issuanceScenario2.id], + credentialDefinitions: [credentialDefinition1.id, credentialDefinition2.id], + personas: [persona1.id, persona2.id], + bannerImage: asset.id, + } + + const savedShowcase = await repository.create(showcase) + expect(savedShowcase).toBeDefined() + + // Get showcase with relations expanded but without asset content + const fromDb = await repository.findById(savedShowcase.id, [ + ShowcaseExpand.SCENARIOS, + ShowcaseExpand.CREDENTIAL_DEFINITIONS, + ShowcaseExpand.PERSONAS, + ]) + + expect(fromDb).toBeDefined() + expect(fromDb.name).toEqual(showcase.name) + expect(fromDb.description).toEqual(showcase.description) + expect(fromDb.status).toEqual(showcase.status) + expect(fromDb.hidden).toEqual(showcase.hidden) + expect(fromDb.scenarios.length).toEqual(2) + expect(fromDb.credentialDefinitions.length).toEqual(2) + expect(fromDb.personas.length).toEqual(2) + + // Check assets are not included or are string IDs + expect(fromDb.bannerImage).toBeDefined() + + // Asset references should be string IDs when ASSET_CONTENT is not expanded + expect(typeof fromDb.bannerImage).toBe('string') + expect(fromDb.bannerImage).toBe(asset.id) + + // Check that persona image references don't have content + for (const persona of fromDb.personas) { + expect(typeof persona.headshotImage).toBe('string') + expect(typeof persona.bodyImage).toBe('string') + } + + // Check that scenario assets don't have content + for (const scenario of fromDb.scenarios) { + for (const step of scenario.steps) { + if (step.asset && typeof step.asset === 'object') { + expect(step.asset.content).not.toBeDefined() + } + } + } + }) + + it('Should get all showcases from database with no expands', async (): Promise => { const showcase: NewShowcase = { name: 'example_name', description: 'example_description', @@ -407,10 +519,151 @@ describe('Database showcase repository tests', (): void => { const savedShowcase2 = await repository.create(showcase) expect(savedShowcase2).toBeDefined() - const fromDb = await repository.findAll() + const fromDb = await repository.findAll([]) expect(fromDb).toBeDefined() expect(fromDb.length).toEqual(2) + fromDb.forEach((showcase) => { + expect(showcase.scenarios).toEqual([]) + expect(showcase.credentialDefinitions).toEqual([]) + expect(showcase.personas).toEqual([]) + expect(showcase.bannerImage).toBeNull() + }) + }) + + it('Should get all showcases from database with all expands including asset content', async (): Promise => { + const showcase: NewShowcase = { + name: 'example_name', + description: 'example_description', + status: ShowcaseStatus.ACTIVE, + hidden: false, + scenarios: [issuanceScenario1.id, issuanceScenario2.id], + credentialDefinitions: [credentialDefinition1.id, credentialDefinition2.id], + personas: [persona1.id, persona2.id], + bannerImage: asset.id, + } + + const savedShowcase1 = await repository.create(showcase) + expect(savedShowcase1).toBeDefined() + + const savedShowcase2 = await repository.create(showcase) + expect(savedShowcase2).toBeDefined() + + const fromDb = await repository.findAll([ + ShowcaseExpand.SCENARIOS, + ShowcaseExpand.CREDENTIAL_DEFINITIONS, + ShowcaseExpand.PERSONAS, + ShowcaseExpand.ASSET_CONTENT, + ]) + + expect(fromDb).toBeDefined() + expect(fromDb.length).toEqual(2) + fromDb.forEach((showcase) => { + expect(showcase.scenarios.length).toEqual(2) + expect(showcase.credentialDefinitions.length).toEqual(2) + expect(showcase.personas.length).toEqual(2) + + // Check that bannerImage has content + if (typeof showcase.bannerImage === 'object' && showcase.bannerImage !== null) { + expect(showcase.bannerImage.content).toBeDefined() + expect(Buffer.isBuffer(showcase.bannerImage.content)).toBeTruthy() + } + }) + }) + + it('Should get all showcases from database with relations expanded but without asset content', async (): Promise => { + const showcase: NewShowcase = { + name: 'example_name', + description: 'example_description', + status: ShowcaseStatus.ACTIVE, + hidden: false, + scenarios: [issuanceScenario1.id, issuanceScenario2.id], + credentialDefinitions: [credentialDefinition1.id, credentialDefinition2.id], + personas: [persona1.id, persona2.id], + bannerImage: asset.id, + } + + const savedShowcase1 = await repository.create(showcase) + expect(savedShowcase1).toBeDefined() + + const savedShowcase2 = await repository.create(showcase) + expect(savedShowcase2).toBeDefined() + + const fromDb = await repository.findAll([ShowcaseExpand.SCENARIOS, ShowcaseExpand.CREDENTIAL_DEFINITIONS, ShowcaseExpand.PERSONAS]) + + expect(fromDb).toBeDefined() + expect(fromDb.length).toEqual(2) + fromDb.forEach((showcase) => { + expect(showcase.scenarios.length).toEqual(2) + expect(showcase.credentialDefinitions.length).toEqual(2) + expect(showcase.personas.length).toEqual(2) + + // Check assets are string IDs or objects without content + if (showcase.bannerImage) { + if (typeof showcase.bannerImage === 'string') { + expect(showcase.bannerImage).toBe(asset.id) + } else if (typeof showcase.bannerImage === 'object') { + expect(showcase.bannerImage.id).toBeDefined() + expect(showcase.bannerImage.content).not.toBeDefined() + } + } + + // Check persona assets + for (const persona of showcase.personas) { + if (persona.headshotImage && typeof persona.headshotImage === 'object') { + expect(persona.headshotImage.content).not.toBeDefined() + } + if (persona.bodyImage && typeof persona.bodyImage === 'object') { + expect(persona.bodyImage.content).not.toBeDefined() + } + } + }) + }) + + it('Should get all showcases from database with all expands', async (): Promise => { + const showcase: NewShowcase = { + name: 'example_name', + description: 'example_description', + status: ShowcaseStatus.ACTIVE, + hidden: false, + scenarios: [issuanceScenario1.id, issuanceScenario2.id], + credentialDefinitions: [credentialDefinition1.id, credentialDefinition2.id], + personas: [persona1.id, persona2.id], + } + + const savedShowcase1 = await repository.create(showcase) + expect(savedShowcase1).toBeDefined() + + const savedShowcase2 = await repository.create(showcase) + expect(savedShowcase2).toBeDefined() + + const fromDb = await repository.findAll([ShowcaseExpand.SCENARIOS, ShowcaseExpand.CREDENTIAL_DEFINITIONS, ShowcaseExpand.PERSONAS]) + + expect(fromDb).toBeDefined() + expect(fromDb.length).toEqual(2) + fromDb.forEach((showcase) => { + expect(showcase.scenarios.length).toEqual(2) + expect(showcase.credentialDefinitions.length).toEqual(2) + expect(showcase.personas.length).toEqual(2) + }) + }) + + it('Should find id by slug', async (): Promise => { + const showcase: NewShowcase = { + name: 'example_name', + description: 'example_description', + status: ShowcaseStatus.ACTIVE, + hidden: false, + scenarios: [issuanceScenario1.id, issuanceScenario2.id], + credentialDefinitions: [credentialDefinition1.id, credentialDefinition2.id], + personas: [persona1.id, persona2.id], + } + + const savedShowcase = await repository.create(showcase) + expect(savedShowcase).toBeDefined() + + const id = await repository.findIdBySlug('example-name') + expect(id).toEqual(savedShowcase.id) }) it('Should delete showcase from database', async (): Promise => { diff --git a/apps/credential-showcase-api-server/src/services/ShowcaseService.ts b/apps/credential-showcase-api-server/src/services/ShowcaseService.ts index 36b2956..d0fd759 100644 --- a/apps/credential-showcase-api-server/src/services/ShowcaseService.ts +++ b/apps/credential-showcase-api-server/src/services/ShowcaseService.ts @@ -1,34 +1,40 @@ +import { + CreateShowcaseParams, + DeleteShowcaseParams, + GetIdBySlugParams, + GetShowcaseParams, + GetShowcasesParams, + Showcase, + UpdateShowcaseParams, +} from '../types' import { Service } from 'typedi' import ShowcaseRepository from '../database/repositories/ShowcaseRepository' -import { Showcase, NewShowcase } from '../types' @Service() -class ShowcaseService { +export class ShowcaseService { constructor(private readonly showcaseRepository: ShowcaseRepository) {} - public getShowcases = async (): Promise => { - return this.showcaseRepository.findAll() + public getShowcases = async (params: GetShowcasesParams = {}): Promise => { + return this.showcaseRepository.findAll(params.expand) } - public getShowcase = async (id: string): Promise => { - return this.showcaseRepository.findById(id) + public getShowcase = async (params: GetShowcaseParams): Promise => { + return this.showcaseRepository.findById(params.id, params.expand) } - public createShowcase = async (showcase: NewShowcase): Promise => { - return this.showcaseRepository.create(showcase) + public createShowcase = async (params: CreateShowcaseParams): Promise => { + return this.showcaseRepository.create(params.showcase) } - public updateShowcase = async (id: string, showcase: NewShowcase): Promise => { - return this.showcaseRepository.update(id, showcase) + public updateShowcase = async (params: UpdateShowcaseParams): Promise => { + return this.showcaseRepository.update(params.id, params.showcase) } - public deleteShowcase = async (id: string): Promise => { - return this.showcaseRepository.delete(id) + public deleteShowcase = async (params: DeleteShowcaseParams): Promise => { + return this.showcaseRepository.delete(params.id) } - public getIdBySlug = async (slug: string): Promise => { - return this.showcaseRepository.findIdBySlug(slug) + public getIdBySlug = async (params: GetIdBySlugParams): Promise => { + return this.showcaseRepository.findIdBySlug(params.slug) } } - -export default ShowcaseService diff --git a/apps/credential-showcase-api-server/src/types/index.ts b/apps/credential-showcase-api-server/src/types/index.ts index db9b863..e5c65cc 100644 --- a/apps/credential-showcase-api-server/src/types/index.ts +++ b/apps/credential-showcase-api-server/src/types/index.ts @@ -1,4 +1,5 @@ export * from './respository' export * from './schema' export * from './scenario' +export * from './services' export * from './slug' diff --git a/apps/credential-showcase-api-server/src/types/schema/index.ts b/apps/credential-showcase-api-server/src/types/schema/index.ts index dcfb463..b123534 100644 --- a/apps/credential-showcase-api-server/src/types/schema/index.ts +++ b/apps/credential-showcase-api-server/src/types/schema/index.ts @@ -22,8 +22,8 @@ export type Asset = typeof assets.$inferSelect export type NewAsset = typeof assets.$inferInsert & { fileName?: string | null; description?: string | null } export type Persona = Omit & { - headshotImage: Asset | null - bodyImage: Asset | null + headshotImage: string | Asset | null + bodyImage: string | Asset | null } export type NewPersona = Omit & { headshotImage?: string | null @@ -72,7 +72,7 @@ export type NewRevocationInfo = Omit & { credentialDefinitions: CredentialDefinition[] - logo: Asset | null + logo: string | Asset | null } export type NewRelyingParty = Omit & { credentialDefinitions: string[] @@ -83,7 +83,7 @@ export type NewRelyingParty = Omit & export type Issuer = Omit & { credentialDefinitions: CredentialDefinition[] credentialSchemas: CredentialSchema[] - logo: Asset | null + logo: string | Asset | null } export type NewIssuer = Omit & { credentialDefinitions: string[] @@ -140,7 +140,7 @@ export type IssuanceScenario = Omit & { personas: string[] @@ -154,7 +154,7 @@ export type PresentationScenario = Omit & { personas: string[] @@ -166,7 +166,7 @@ export type NewPresentationScenario = Omit & { actions: AriesOOBAction[] - asset?: Asset | null + asset?: string | Asset | null } export type NewStep = Omit & { asset?: string | null @@ -200,7 +200,7 @@ export type Showcase = Omit & { scenarios: Scenario[] credentialDefinitions: CredentialDefinition[] personas: Persona[] - bannerImage?: Asset | null + bannerImage?: string | Asset | null } export type NewShowcase = Omit & { scenarios: string[] @@ -219,3 +219,12 @@ export enum ShowcaseStatus { ACTIVE = 'ACTIVE', ARCHIVED = 'ARCHIVED', } + +export const ShowcaseExpand = { + SCENARIOS: 'SCENARIOS', + CREDENTIAL_DEFINITIONS: 'CREDENTIAL_DEFINITIONS', + PERSONAS: 'PERSONAS', + ASSET_CONTENT: 'ASSET_CONTENT', +} as const + +export type ShowcaseExpand = (typeof ShowcaseExpand)[keyof typeof ShowcaseExpand] diff --git a/apps/credential-showcase-api-server/src/types/services/index.ts b/apps/credential-showcase-api-server/src/types/services/index.ts new file mode 100644 index 0000000..6df297b --- /dev/null +++ b/apps/credential-showcase-api-server/src/types/services/index.ts @@ -0,0 +1,27 @@ +import { NewShowcase, ShowcaseExpand } from '../schema' + +export type GetShowcasesParams = { + expand?: ShowcaseExpand[] +} + +export type GetShowcaseParams = { + id: string + expand?: ShowcaseExpand[] +} + +export type CreateShowcaseParams = { + showcase: NewShowcase +} + +export type UpdateShowcaseParams = { + id: string + showcase: NewShowcase +} + +export type DeleteShowcaseParams = { + id: string +} + +export type GetIdBySlugParams = { + slug: string +} diff --git a/apps/credential-showcase-api-server/src/utils/mappers.ts b/apps/credential-showcase-api-server/src/utils/mappers.ts index 2b930a0..0c91057 100644 --- a/apps/credential-showcase-api-server/src/utils/mappers.ts +++ b/apps/credential-showcase-api-server/src/utils/mappers.ts @@ -61,7 +61,12 @@ export const credentialDefinitionDTOFrom = (credentialDefinition: CredentialDefi credentialSchema: credentialSchemaDTOFrom(credentialDefinition.credentialSchema), representations: credentialDefinition.representations, revocation: credentialDefinition.revocation || undefined, - icon: assetDTOFrom(credentialDefinition.icon), + icon: + typeof credentialDefinition.icon === 'string' + ? { id: credentialDefinition.icon } + : credentialDefinition.icon + ? assetDTOFrom(credentialDefinition.icon as Asset) + : undefined, } } @@ -69,7 +74,8 @@ export const relyingPartyDTOFrom = (relyingParty: RelyingParty): RelyingPartyDTO return { ...relyingParty, organization: relyingParty.organization || undefined, - logo: relyingParty.logo ? assetDTOFrom(relyingParty.logo) : undefined, + logo: + typeof relyingParty.logo === 'string' ? { id: relyingParty.logo } : relyingParty.logo ? assetDTOFrom(relyingParty.logo as Asset) : undefined, credentialDefinitions: relyingParty.credentialDefinitions.map(credentialDefinitionDTOFrom), } } @@ -78,7 +84,7 @@ export const issuerDTOFrom = (issuer: Issuer): IssuerDTO => { return { ...issuer, organization: issuer.organization || undefined, - logo: issuer.logo ? assetDTOFrom(issuer.logo) : undefined, + logo: typeof issuer.logo === 'string' ? { id: issuer.logo } : issuer.logo ? assetDTOFrom(issuer.logo as Asset) : undefined, credentialDefinitions: issuer.credentialDefinitions.map(credentialDefinitionDTOFrom), credentialSchemas: issuer.credentialSchemas.map(credentialSchemaDTOFrom), } @@ -95,6 +101,12 @@ export const issuanceScenarioDTOFrom = (issuanceScenario: IssuanceScenario): Iss type: ScenarioType.ISSUANCE, steps: issuanceScenario.steps.map(stepDTOFrom), personas: issuanceScenario.personas.map(personaDTOFrom), + bannerImage: + typeof issuanceScenario.bannerImage === 'string' + ? { id: issuanceScenario.bannerImage } + : issuanceScenario.bannerImage + ? assetDTOFrom(issuanceScenario.bannerImage as Asset) + : undefined, } } @@ -109,6 +121,12 @@ export const presentationScenarioDTOFrom = (presentationScenario: PresentationSc type: ScenarioType.PRESENTATION, steps: presentationScenario.steps.map(stepDTOFrom), personas: presentationScenario.personas.map(personaDTOFrom), + bannerImage: + typeof presentationScenario.bannerImage === 'string' + ? { id: presentationScenario.bannerImage } + : presentationScenario.bannerImage + ? assetDTOFrom(presentationScenario.bannerImage as Asset) + : undefined, } } @@ -126,7 +144,7 @@ export const scenarioDTOFrom = (scenario: Scenario): IssuanceScenarioDTO | Prese export const stepDTOFrom = (step: Step): StepDTO => { return { ...step, - asset: step.asset ? assetDTOFrom(step.asset) : undefined, + asset: typeof step.asset === 'string' ? { id: step.asset } : step.asset ? assetDTOFrom(step.asset as Asset) : undefined, subScenario: step.subScenario || undefined, } } @@ -134,8 +152,14 @@ export const stepDTOFrom = (step: Step): StepDTO => { export const personaDTOFrom = (persona: Persona): PersonaDTO => { return { ...persona, - headshotImage: persona.headshotImage ? assetDTOFrom(persona.headshotImage) : undefined, - bodyImage: persona.bodyImage ? assetDTOFrom(persona.bodyImage) : undefined, + headshotImage: + typeof persona.headshotImage === 'string' + ? { id: persona.headshotImage } + : persona.headshotImage + ? assetDTOFrom(persona.headshotImage as Asset) + : undefined, + bodyImage: + typeof persona.bodyImage === 'string' ? { id: persona.bodyImage } : persona.bodyImage ? assetDTOFrom(persona.bodyImage as Asset) : undefined, hidden: persona.hidden, } } @@ -143,10 +167,17 @@ export const personaDTOFrom = (persona: Persona): PersonaDTO => { export const showcaseDTOFrom = (showcase: Showcase): ShowcaseDTO => { return { ...showcase, - personas: showcase.personas.map(personaDTOFrom), - credentialDefinitions: showcase.credentialDefinitions.map(credentialDefinitionDTOFrom), - scenarios: showcase.scenarios.map(scenarioDTOFrom), - bannerImage: showcase.bannerImage ? assetDTOFrom(showcase.bannerImage) : undefined, + personas: showcase.personas.map((persona) => (typeof persona === 'string' ? { id: persona } : personaDTOFrom(persona as Persona))), + credentialDefinitions: showcase.credentialDefinitions.map((credentialDef) => + typeof credentialDef === 'string' ? { id: credentialDef } : credentialDefinitionDTOFrom(credentialDef as CredentialDefinition), + ), + scenarios: showcase.scenarios.map((scenario) => (typeof scenario === 'string' ? { id: scenario } : scenarioDTOFrom(scenario as Scenario))), + bannerImage: + typeof showcase.bannerImage === 'string' + ? { id: showcase.bannerImage } + : showcase.bannerImage + ? assetDTOFrom(showcase.bannerImage as Asset) + : undefined, completionMessage: showcase.completionMessage || undefined, } } diff --git a/apps/credential-showcase-api-server/src/utils/normalize.ts b/apps/credential-showcase-api-server/src/utils/normalize.ts new file mode 100644 index 0000000..4322b89 --- /dev/null +++ b/apps/credential-showcase-api-server/src/utils/normalize.ts @@ -0,0 +1,31 @@ +import { ShowcaseExpand } from 'credential-showcase-openapi' +import { BadRequestError } from 'routing-controllers' + +/** + * Normalizes expand parameters to valid ShowcaseExpand enum values + * + * @param expand - Array of expand parameter strings from the request + * @returns Array of valid ShowcaseExpand enum values + */ +export const normalizeExpandParams = (expand?: string[]): ShowcaseExpand[] => { + const expandMap: Record = { + scenarios: ShowcaseExpand.Scenarios, + credentialdefinitions: ShowcaseExpand.CredentialDefinitions, + credential_definitions: ShowcaseExpand.CredentialDefinitions, + personas: ShowcaseExpand.Personas, + assetcontent: ShowcaseExpand.AssetContent, + asset_content: ShowcaseExpand.AssetContent, + } + + return ( + (expand + ?.map((expandValue) => { + const normalizedKey = expandValue.toLowerCase().trim() + if (normalizedKey in expandMap) { + return expandMap[normalizedKey as keyof typeof expandMap] + } + throw new BadRequestError(`Invalid expand parameter: ${expandValue}`) + }) + .filter(Boolean) as ShowcaseExpand[]) || [] + ) +} diff --git a/docker/dev/README.md b/docker/dev/README.md index 20669be..86dad56 100644 --- a/docker/dev/README.md +++ b/docker/dev/README.md @@ -58,6 +58,7 @@ docker-compose up -d ``` This will start: + - The API server accessible on port defined in your `.env` file - The Traction adapter service - PostgreSQL database with persistent storage @@ -66,6 +67,7 @@ This will start: ## Network Configuration The system uses two isolated Docker networks: + - `messagebroker_net`: For RabbitMQ communication - `db_net`: For database access @@ -93,6 +95,7 @@ To push the images to a Docker registry: ``` The script: + - Checks that API server and Traction adapter versions match - Tags images with the appropriate version number from package.json - Pushes images to the configured registry (default: sphereonregistry.azurecr.io) @@ -109,4 +112,4 @@ The script: - Verify network connectivity between services - Ensure RabbitMQ credentials are correct - Check PostgreSQL connection parameters -- If push script fails, verify your Docker registry credentials and connection \ No newline at end of file +- If push script fails, verify your Docker registry credentials and connection diff --git a/docker/dev/docker-compose.yml b/docker/dev/docker-compose.yml index cb98e25..b8a9145 100644 --- a/docker/dev/docker-compose.yml +++ b/docker/dev/docker-compose.yml @@ -26,9 +26,9 @@ services: - ALLOW_HEADERS=${ALLOW_HEADERS} - ALLOW_CREDENTIALS=${ALLOW_CREDENTIALS} depends_on: - - postgres # Ensure Postgres starts first + - postgres # Ensure Postgres starts first ports: - - "${API_PORT}:3000" # remove when enabling proxy + - '${API_PORT}:3000' # remove when enabling proxy credential-showcase-traction-adapter: build: @@ -48,7 +48,7 @@ services: - APP_NAME=${APP_NAME} - LOG_LEVEL=${LOG_LEVEL} depends_on: - - rabbitmq # Ensure RabbitMQ starts first + - rabbitmq # Ensure RabbitMQ starts first postgres: image: postgres:16 @@ -60,17 +60,17 @@ services: - POSTGRES_PASSWORD=${DB_PASSWORD} - POSTGRES_DB=${DB_NAME} ports: - - "${DB_EXPOSED_PORT}:5432" # Expose Postgres port, default 5432 + - '${DB_EXPOSED_PORT}:5432' # Expose Postgres port, default 5432 volumes: - postgres_data:/var/lib/postgresql/data healthcheck: - test: ["CMD", "pg_isready", "-U", "${DB_USER}"] + test: ['CMD', 'pg_isready', '-U', '${DB_USER}'] interval: 10s timeout: 5s retries: 5 rabbitmq: - image: rabbitmq:4-management # Using RabbitMQ 4.x with management plugin + image: rabbitmq:4-management # Using RabbitMQ 4.x with management plugin restart: unless-stopped networks: - messagebroker_net @@ -78,11 +78,11 @@ services: - RABBITMQ_DEFAULT_USER=${RABBITMQ_USER} - RABBITMQ_DEFAULT_PASS=${RABBITMQ_PASSWORD} ports: - - "${RABBITMQ_EXPOSED_PORT:-5672}:5672" - - "${RABBITMQ_MGMT_EXPOSED_PORT:-15672}:15672" + - '${RABBITMQ_EXPOSED_PORT:-5672}:5672' + - '${RABBITMQ_MGMT_EXPOSED_PORT:-15672}:15672' volumes: - postgres_data: # Named volume for Postgres data persistence + postgres_data: # Named volume for Postgres data persistence networks: api_net: @@ -92,8 +92,8 @@ networks: messagebroker_net: driver: bridge name: messagebroker_net - internal: false # set to false to be able to expose for debugging + internal: false # set to false to be able to expose for debugging db_net: driver: bridge name: db_net - internal: false # set to false to be able to expose for debugging \ No newline at end of file + internal: false # set to false to be able to expose for debugging diff --git a/docker/prod/docker-compose.yml b/docker/prod/docker-compose.yml index cbd948c..d24d68d 100644 --- a/docker/prod/docker-compose.yml +++ b/docker/prod/docker-compose.yml @@ -18,17 +18,17 @@ services: - APP_NAME=${APP_NAME} - LOG_LEVEL=${LOG_LEVEL} depends_on: - - postgres # Ensure Postgres starts first + - postgres # Ensure Postgres starts first ports: - - "${API_PORT}:3000" # remove when enabling proxy + - '${API_PORT}:3000' # remove when enabling proxy labels: - - "traefik.enable=true" - - "traefik.docker.network=frontend" - - "traefik.http.routers.credential-showcase-api-server.entrypoints=websecure" - - "traefik.http.routers.credential-showcase-api-server.rule=${API_PUBLIC_HOSTS}" - - "traefik.http.routers.credential-showcase-api-server.tls.certresolver=acmeresolver" - - "traefik.http.services.credential-showcase-api-server.loadbalancer.server.port=3000" - - "traefik.http.services.credential-showcase-api-server.loadbalancer.server.scheme=http" + - 'traefik.enable=true' + - 'traefik.docker.network=frontend' + - 'traefik.http.routers.credential-showcase-api-server.entrypoints=websecure' + - 'traefik.http.routers.credential-showcase-api-server.rule=${API_PUBLIC_HOSTS}' + - 'traefik.http.routers.credential-showcase-api-server.tls.certresolver=acmeresolver' + - 'traefik.http.services.credential-showcase-api-server.loadbalancer.server.port=3000' + - 'traefik.http.services.credential-showcase-api-server.loadbalancer.server.scheme=http' credential-showcase-traction-adapter: image: ${DOCKER_REGISTRY:-sphereonregistry.azurecr.io}/credential-showcase-traction-adapter:latest @@ -45,7 +45,7 @@ services: - APP_NAME=${APP_NAME} - LOG_LEVEL=${LOG_LEVEL} depends_on: - - rabbitmq # Ensure RabbitMQ starts first + - rabbitmq # Ensure RabbitMQ starts first postgres: image: postgres:16 @@ -59,13 +59,13 @@ services: volumes: - postgres_data:/var/lib/postgresql/data healthcheck: - test: [ "CMD", "pg_isready", "-U", "${DB_USER}" ] + test: ['CMD', 'pg_isready', '-U', '${DB_USER}'] interval: 10s timeout: 5s retries: 5 rabbitmq: - image: rabbitmq:4-management # Using RabbitMQ 4.x with management plugin + image: rabbitmq:4-management # Using RabbitMQ 4.x with management plugin restart: unless-stopped networks: - messagebroker_net @@ -73,13 +73,13 @@ services: - RABBITMQ_DEFAULT_USER=${RABBITMQ_USER} - RABBITMQ_DEFAULT_PASS=${RABBITMQ_PASSWORD} ports: - - "${RABBITMQ_EXPOSED_PORT:-5672}:5672" - - "${RABBITMQ_MGMT_EXPOSED_PORT:-15672}:15672" + - '${RABBITMQ_EXPOSED_PORT:-5672}:5672' + - '${RABBITMQ_MGMT_EXPOSED_PORT:-15672}:15672' traefik: image: traefik:latest profiles: - - traefik # CONDITIONAL - set COMPOSE_PROFILES=traefik to enable + - traefik # CONDITIONAL - set COMPOSE_PROFILES=traefik to enable command: > --providers.docker --providers.docker.exposedbydefault=false @@ -95,8 +95,8 @@ services: --api.dashboard=false --log.level=INFO ports: - - "80:80" - - "443:443" + - '80:80' + - '443:443' volumes: - /var/run/docker.sock:/var/run/docker.sock - ./cert/:/cert/ @@ -104,20 +104,20 @@ services: networks: - frontend labels: - - "traefik.enable=true" + - 'traefik.enable=true' volumes: - postgres_data: # Named volume for Postgres data persistence + postgres_data: # Named volume for Postgres data persistence networks: messagebroker_net: driver: bridge name: messagebroker_net - internal: true # not exposed when set to true + internal: true # not exposed when set to true db_net: driver: bridge name: db_net - internal: true # not exposed when set to true + internal: true # not exposed when set to true frontend: driver: bridge name: frontend_net diff --git a/jest.json b/jest.json index 0b76f3c..985bdcc 100644 --- a/jest.json +++ b/jest.json @@ -1,12 +1,7 @@ { "preset": "ts-jest", "testTimeout": 60000, - "moduleFileExtensions": [ - "ts", - "js", - "json", - "jsonld" - ], + "moduleFileExtensions": ["ts", "js", "json", "jsonld"], "collectCoverage": true, "collectCoverageFrom": [ "packages/**/src/**/*.ts", @@ -17,14 +12,8 @@ "!**/node_modules/**", "!**/packages/**/index.ts" ], - "coveragePathIgnorePatterns": [ - "packages/credential-showcase-openapi" - ], - "coverageReporters": [ - "text", - "lcov", - "json" - ], + "coveragePathIgnorePatterns": ["packages/credential-showcase-openapi"], + "coverageReporters": ["text", "lcov", "json"], "coverageDirectory": "./coverage", "transform": { "\\.jsx?$": "babel-jest", @@ -35,10 +24,7 @@ } ] }, - "testMatch": [ - "**/__tests__/**/*.test.*", - "!dist/*" - ], + "testMatch": ["**/__tests__/**/*.test.*", "!dist/*"], "testEnvironment": "node", "automock": false, "verbose": true diff --git a/packages/credential-showcase-openapi/openapi/openapi.yaml b/packages/credential-showcase-openapi/openapi/openapi.yaml index 88266cd..2f0eb18 100644 --- a/packages/credential-showcase-openapi/openapi/openapi.yaml +++ b/packages/credential-showcase-openapi/openapi/openapi.yaml @@ -86,7 +86,7 @@ paths: schema: type: string get: - tags: [ "Issuance Scenario" ] + tags: ['Issuance Scenario'] summary: Retrieve a single issuance scenario operationId: getIssuanceScenario responses: @@ -107,7 +107,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' put: - tags: [ "Issuance Scenario" ] + tags: ['Issuance Scenario'] summary: Update an issuance scenario (overwrite) operationId: updateIssuanceScenario requestBody: @@ -134,7 +134,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' delete: - tags: [ "Issuance Scenario" ] + tags: ['Issuance Scenario'] summary: Delete an issuance scenario operationId: deleteIssuanceScenario responses: @@ -160,7 +160,7 @@ paths: type: string get: tags: - - "Issuance Scenario" + - 'Issuance Scenario' summary: List steps in an issuance scenario operationId: listIssuanceScenarioSteps responses: @@ -181,7 +181,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' post: - tags: [ "Issuance Scenario" ] + tags: ['Issuance Scenario'] summary: Add a step to an issuance scenario operationId: createIssuanceScenarioStep requestBody: @@ -220,7 +220,7 @@ paths: schema: type: string get: - tags: [ "Issuance Scenario" ] + tags: ['Issuance Scenario'] summary: Retrieve a specific step in an issuance scenario operationId: getIssuanceScenarioStep responses: @@ -241,7 +241,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' put: - tags: [ "Issuance Scenario" ] + tags: ['Issuance Scenario'] summary: Overwrite a step in an issuance scenario operationId: updateIssuanceScenarioStep requestBody: @@ -268,7 +268,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' delete: - tags: [ "Issuance Scenario" ] + tags: ['Issuance Scenario'] summary: Delete a step in an issuance scenario operationId: deleteIssuanceScenarioStep responses: @@ -298,7 +298,7 @@ paths: schema: type: string get: - tags: [ "Issuance Scenario" ] + tags: ['Issuance Scenario'] summary: List actions in a step operationId: listStepActions responses: @@ -319,7 +319,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' post: - tags: [ "Issuance Scenario" ] + tags: ['Issuance Scenario'] summary: Create an action in a step operationId: createStepAction requestBody: @@ -363,7 +363,7 @@ paths: schema: type: string get: - tags: [ "Issuance Scenario" ] + tags: ['Issuance Scenario'] summary: Retrieve a single action operationId: getStepAction responses: @@ -384,7 +384,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' put: - tags: [ "Issuance Scenario" ] + tags: ['Issuance Scenario'] summary: Overwrite an action operationId: updateStepAction requestBody: @@ -411,7 +411,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' delete: - tags: [ "Issuance Scenario" ] + tags: ['Issuance Scenario'] summary: Delete an action operationId: deleteStepAction responses: @@ -483,7 +483,7 @@ paths: schema: type: string get: - tags: [ "Presentation Scenario" ] + tags: ['Presentation Scenario'] summary: Retrieve a single presentation scenario operationId: getPresentationScenario responses: @@ -504,7 +504,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' put: - tags: [ "Presentation Scenario" ] + tags: ['Presentation Scenario'] summary: Update a presentation scenario (overwrite) operationId: updatePresentationScenario requestBody: @@ -531,7 +531,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' delete: - tags: [ "Presentation Scenario" ] + tags: ['Presentation Scenario'] summary: Delete a presentation scenario operationId: deletePresentationScenario responses: @@ -557,7 +557,7 @@ paths: type: string get: tags: - - "Presentation Scenario" + - 'Presentation Scenario' summary: List steps in a presentation scenario operationId: listPresentationScenarioSteps responses: @@ -578,7 +578,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' post: - tags: [ "Presentation Scenario" ] + tags: ['Presentation Scenario'] summary: Add a step to a presentation scenario operationId: createPresentationScenarioStep requestBody: @@ -617,7 +617,7 @@ paths: schema: type: string get: - tags: [ "Presentation Scenario" ] + tags: ['Presentation Scenario'] summary: Retrieve a specific step in a presentation scenario operationId: getPresentationScenarioStep responses: @@ -638,7 +638,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' put: - tags: [ "Presentation Scenario" ] + tags: ['Presentation Scenario'] summary: Overwrite a step in a presentation scenario operationId: updatePresentationScenarioStep requestBody: @@ -665,7 +665,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' delete: - tags: [ "Presentation Scenario" ] + tags: ['Presentation Scenario'] summary: Delete a step in a presentation scenario operationId: deletePresentationScenarioStep responses: @@ -695,7 +695,7 @@ paths: schema: type: string get: - tags: [ "Presentation Scenario" ] + tags: ['Presentation Scenario'] summary: List actions in a step operationId: listPresentationScenarioStepActions responses: @@ -716,7 +716,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' post: - tags: [ "Presentation Scenario" ] + tags: ['Presentation Scenario'] summary: Create an action in a step operationId: createPresentationScenarioStepAction requestBody: @@ -760,7 +760,7 @@ paths: schema: type: string get: - tags: [ "Presentation Scenario" ] + tags: ['Presentation Scenario'] summary: Retrieve a single action operationId: getPresentationScenarioStepAction responses: @@ -781,7 +781,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' put: - tags: [ "Presentation Scenario" ] + tags: ['Presentation Scenario'] summary: Overwrite an action operationId: updatePresentationScenarioStepAction requestBody: @@ -808,7 +808,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' delete: - tags: [ "Presentation Scenario" ] + tags: ['Presentation Scenario'] summary: Delete an action operationId: deletePresentationScenarioStepAction responses: @@ -1525,6 +1525,12 @@ paths: - Showcases summary: List all showcases operationId: listShowcases + parameters: + - name: expand + in: query + required: false + schema: + $ref: '#/components/schemas/ShowcaseExpands' responses: '200': description: OK @@ -1578,6 +1584,12 @@ paths: get: tags: - Showcases + parameters: + - name: expand + in: query + required: false + schema: + $ref: '#/components/schemas/ShowcaseExpands' summary: Get a specific showcase operationId: getShowcase responses: @@ -1667,10 +1679,6 @@ components: type: object required: - id - - mediaType - - content - - createdAt - - updatedAt properties: id: type: string @@ -1780,6 +1788,9 @@ components: type: array items: $ref: '#/components/schemas/StepAction' + assetId: + type: string + description: The asset id asset: $ref: '#/components/schemas/Asset' createdAt: @@ -2046,12 +2057,6 @@ components: type: object required: - id - - name - - slug - - role - - description - - createdAt - - updatedAt properties: id: type: string @@ -2135,14 +2140,6 @@ components: type: object required: - id - - name - - slug - - type - - description - - steps - - personas - - createdAt - - updatedAt properties: id: type: string @@ -2186,6 +2183,8 @@ components: description: Date and time the scenario was last updated format: date-time example: 2025-03-06T11:30:16.573Z + bannerImage: + $ref: '#/components/schemas/Asset' ScenarioRequest: type: object required: @@ -2230,7 +2229,7 @@ components: type: object properties: issuanceScenario: - $ref: '#/components/schemas/IssuanceScenario' + $ref: '#/components/schemas/IssuanceScenario' IssuanceScenario: type: object allOf: @@ -2252,7 +2251,7 @@ components: properties: issuer: type: string - example: "313e4567-e89b-12d3-a456-426614174469" + example: '313e4567-e89b-12d3-a456-426614174469' description: Scenario specialization for credential issuance PresentationScenariosResponse: @@ -2287,7 +2286,7 @@ components: properties: relyingParty: type: string - example: "313e4567-e89b-12d3-a456-426614174469" + example: '313e4567-e89b-12d3-a456-426614174469' IdentifierType: type: string @@ -2347,6 +2346,9 @@ components: type: string description: Organization the issuer belongs to example: Acme Corporation + logoId: + type: string + description: The asset id logo: $ref: '#/components/schemas/Asset' credentialDefinitions: @@ -2361,12 +2363,12 @@ components: type: string description: Date and time the issuer was created format: date-time - example: "2025-03-06T11:30:16.573Z" + example: '2025-03-06T11:30:16.573Z' updatedAt: type: string description: Date and time the issuer was last updated format: date-time - example: "2025-03-06T11:30:16.573Z" + example: '2025-03-06T11:30:16.573Z' IssuerRequest: type: object required: @@ -2451,6 +2453,9 @@ components: type: string description: Organization the relying party belongs to example: Acme Corporation + logoId: + type: string + description: The asset id logo: $ref: '#/components/schemas/Asset' credentialDefinitions: @@ -2461,12 +2466,12 @@ components: type: string description: Date and time the relying party was created format: date-time - example: "2025-03-06T11:30:16.573Z" + example: '2025-03-06T11:30:16.573Z' updatedAt: type: string description: Date and time the relying party was last updated format: date-time - example: "2025-03-06T11:30:16.573Z" + example: '2025-03-06T11:30:16.573Z' RelyingPartyRequest: type: object required: @@ -2531,15 +2536,6 @@ components: type: object required: - id - - name - - version - - type - - credentialSchema - - icon - # TODO enable back in SHOWCASE-81 - # - representations - - createdAt - - updatedAt properties: id: type: string @@ -2573,6 +2569,9 @@ components: oneOf: - $ref: '#/components/schemas/RevocationInfo' - $ref: '#/components/schemas/AnonCredRevocation' + iconId: + type: string + description: The asset id icon: $ref: '#/components/schemas/Asset' createdAt: @@ -2641,7 +2640,7 @@ components: properties: credentialDefinitions: type: array - description: "List of credential definitions" + description: 'List of credential definitions' items: $ref: '#/components/schemas/CredentialDefinition' CredentialDefinitionResponse: @@ -2801,7 +2800,7 @@ components: id: type: string description: Unique identifier for the credential schema - example: 123e4567-e89b-12d3-a456-426614174123 + example: 123e4567-e89b-12d3-a456-426614174123 name: type: string description: Name of the credential schema @@ -2864,7 +2863,7 @@ components: properties: credentialSchemas: type: array - description: "List of credential schemas" + description: 'List of credential schemas' items: $ref: '#/components/schemas/CredentialSchema' CredentialSchemaResponse: @@ -2914,23 +2913,23 @@ components: type: array description: List of scenarios in this showcase items: - $ref: '#/components/schemas/Scenario' + $ref: '#/components/schemas/Scenario' credentialDefinitions: type: array description: List of credential definitions used in this showcase items: - $ref: '#/components/schemas/CredentialDefinition' + $ref: '#/components/schemas/CredentialDefinition' personas: type: object description: List of personas involved in this showcase items: - $ref: '#/components/schemas/Persona' + $ref: '#/components/schemas/Persona' bannerImage: $ref: '#/components/schemas/Asset' completionMessage: type: string description: Message to display when the showcase is completed - example: "You have successfully completed the showcase" + example: 'You have successfully completed the showcase' createdAt: type: string description: Date and time the showcase was created @@ -2946,7 +2945,7 @@ components: properties: showcases: type: array - description: "List of showcases" + description: 'List of showcases' items: $ref: '#/components/schemas/Showcase' ShowcaseResponse: @@ -3001,14 +3000,14 @@ components: example: 123e4567-e89b-12d3-a456-426614174469 completionMessage: type: string - example: "You have successfully completed the showcase" + example: 'You have successfully completed the showcase' ShowcaseStatus: type: string enum: - - PENDING - - ACTIVE - - ARCHIVED + - PENDING + - ACTIVE + - ARCHIVED description: Types of supported credentials example: PENDING @@ -3019,6 +3018,19 @@ components: - PRESENTATION description: Types of supported scenarios example: ISSUANCE + ShowcaseExpands: + type: array + description: Which entities to expand + items: + $ref: '#/components/schemas/ShowcaseExpand' + ShowcaseExpand: + type: string + description: Which entity to expand + enum: + - SCENARIOS + - CREDENTIAL_DEFINITIONS + - PERSONAS + - ASSET_CONTENT responses: 'BadRequest': diff --git a/packages/credential-showcase-openapi/pom.xml b/packages/credential-showcase-openapi/pom.xml index 264f6f1..16f50bf 100644 --- a/packages/credential-showcase-openapi/pom.xml +++ b/packages/credential-showcase-openapi/pom.xml @@ -99,7 +99,7 @@ false UTF-8 - 7.11.0 + 7.12.0 3.9.0 17 17 diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 325664a..e8ab696 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -2566,6 +2566,11 @@ packages: engines: {node: 20 || >=22} hasBin: true + rimraf@6.0.1: + resolution: {integrity: sha512-9dkvaxAsk/xNXSJzMgFqqMCuFgt2+KsOFek3TMLfo8NCPfWpBmqwyNn5Y+NX56QUYfCtsyhF3ayiboEoUmJk/A==} + engines: {node: 20 || >=22} + hasBin: true + routing-controllers@0.11.1: resolution: {integrity: sha512-IGHHR+SpLsmDLUpYmGCwAwg1d6bobugNLlBfljnWnXEwQJhx1FGHOc93aQrErixkT3GiNxkgkVlZeFBXYcZ0LA==} peerDependencies: diff --git a/postman/credential-showcase-api.postman_collection.json b/postman/credential-showcase-api.postman_collection.json index c47f2c2..36662a9 100644 --- a/postman/credential-showcase-api.postman_collection.json +++ b/postman/credential-showcase-api.postman_collection.json @@ -1,1549 +1,1188 @@ { - "info": { - "_postman_id": "4658d37d-77a6-486a-aaf1-4f3f7cbd76f7", - "name": "credential-showcase-api", - "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json", - "_exporter_id": "10630815" - }, - "item": [ - { - "name": "assets", - "item": [ - { - "name": "assets", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/assets", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "assets" - ] - } - }, - "response": [] - }, - { - "name": "asset", - "request": { - "method": "POST", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"mediaType\": \"image/jpeg\",\r\n \"content\": \"/9j/4AAQSkZJRgABAQEASABIAAD/4gIcSUNDX1BST0ZJTEUAAQEAAAIMbGNtcwIQAABtbnRyUkdCIFhZWiAH3AABABkAAwApADlhY3NwQVBQTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9tYAAQAAAADTLWxjbXMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApkZXNjAAAA/AAAAF5jcHJ0AAABXAAAAAt3dHB0AAABaAAAABRia3B0AAABfAAAABRyWFlaAAABkAAAABRnWFlaAAABpAAAABRiWFlaAAABuAAAABRyVFJDAAABzAAAAEBnVFJDAAABzAAAAEBiVFJDAAABzAAAAEBkZXNjAAAAAAAAAANjMgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0ZXh0AAAAAElYAABYWVogAAAAAAAA9tYAAQAAAADTLVhZWiAAAAAAAAADFgAAAzMAAAKkWFlaIAAAAAAAAG+iAAA49QAAA5BYWVogAAAAAAAAYpkAALeFAAAY2lhZWiAAAAAAAAAkoAAAD4QAALbPY3VydgAAAAAAAAAaAAAAywHJA2MFkghrC/YQPxVRGzQh8SmQMhg7kkYFUXdd7WtwegWJsZp8rGm/fdPD6TD////bAIQABQYGBwkHCgsLCg0ODQ4NExIQEBITHRUWFRYVHSsbIBsbIBsrJi4mIyYuJkQ2MDA2RE9CP0JPX1VVX3hyeJyc0gEFBgYHCQcKCwsKDQ4NDg0TEhAQEhMdFRYVFhUdKxsgGxsgGysmLiYjJi4mRDYwMDZET0I/Qk9fVVVfeHJ4nJzS/8IAEQgC8QH0AwEiAAIRAQMRAf/EADMAAAAHAQEAAAAAAAAAAAAAAAABAgQFBgcDCAEAAwEBAQAAAAAAAAAAAAAAAAECAwQF/9oADAMBAAIQAxAAAADzmZkIyMxEDIZqBiBpMCAAEYUIGkxgyMDBgDIyAGDAwQAzJQEFEIlgDMyAAAgBGBAGY0hRCANSAS0NkAAQFgAYISeiVAZgkdl8lAoIAgQAAGEoYjFWYBgS+awWgwBGABpMwBkoCBgDMwBpWAQYSCjAEZgxp6EoCSZiMAJkoGxIAQCBNGDUCTBINSFMUkyTJKjEk1k2QIwMwpBAzEFEAUSktEZmCQYCFCiKAAGakqERrICMLDmFgEEtIKBmBL5rAwRghQUBF1IADAEpIA0mACgAUpCgQZmhBmBpUAIgowIKDAAEJ6EsCT0SHNYUwjUSCBKBIMCUlZAAABAwnCmR0AwoEmSgMAwCkmAIjAwDAjAAyMAlRqBCgBGFJGa0GIEtIyClAk1EBkDBBqJBmRjM0GIwABGAIGFDBhCFkDYnohYIC0iUEGCkmQGDAERAFhICII1NkYAAwAUABgGBEZqAjJIGkzGFJNIwCYpfNYGAYyIARgyBZBQEFEggYYpJhBGaANSQBkDA1AARoAlpBAoEAMyQCwgwUrmBLCDDoEgagaQIABGAG2CCgMjMZGDA0gCNQIEgwBmS0BPVAEoGxBgwSZKBKjIFkQAKQA6hBoMAmGDAiASmogQKMgCjQBKBKAJNIA0mAUkxLLpzGkgGgslINIJHQkLYYATigoUyMwBL5qAKJQAjUBAAEgzAjK+RVQcejWvH0ebk7hh/TiQQeuajIAZBILAJigQBRESOgINKCVJhCiYDBJKPmoYBEJQ5qGoiJpQJQiMiR0JK2AyAGZGIJVzlqBGxQINR6uayzIjAlEoFECGoAhECMYUAKa0+p1bj6LzY8/uuWsxASq+PfC02yq+x5xEBrBmlYGkgBqQEdCBNKCQNQSQupIMZkQEZkYAICSwABkSgMgQEog0paDGskpBZEQdEmkSjSYGCCGBpN2ZpMayIAFIMFpIgNRJF0BKTu0Fa4rk6VWiq2man6vYITHS2YdoE5leIKIex5qwkmjPmsDIiDqOZiUaFDMJMOhJUJCySCgQGoEEjAIDVzUCggNLPmoFkABGZCIGQKCTAAjSUCCceoirRSuSgWEgRqQBqCACwlILds+or+QkuPrccpu4oz1laovO6zda/E46Pcx9MefunnhwRd3MoAxAgBgAwM0gRgECjCQWEKAGQAwkwWkARhIQYSpijSoRmkAoJIS0pJPofMNLIgBggkzBE9VGkAskgFJNALNABZEAV3bSQaU2mmHF2V/UMulw0KrWyFSga3f6dnpI2Wk6lhXmlM9XfW89ZoK11JAAwSRdAkwURAFGQAzQAWSQLofNQGpABZEYGRJF1SRDWaDEoiSCkBQEaTAL5mHUJAmRpBoo0AFERAsIUBkRAo0AFTtfvad5i5yJ870IuOurnXOPtBcSWkOoZaNifUVLWPPG4VOozY0uu/la9OTlnJL1qIjSGjMzGROeCSQEtKNAGtXMw6BKRdUoALJJh0SkgUfNQlkgAtXNYLLilPsAGgEhpuEktDCSEsiMZhIAwkAoiMFa7kez51daRpFL4fQhGRO7J20UF3phaK5ExuL5tV9o0j9ewm9JUpzrOMa5ue1m0jbPCU6vVamjddjqlKuOJZmlJZ7qcSGak8Y7QZBLFhBh1CSEoiIFnzMFnzMFEXdHJ9dtK4+jzl39DCL8uvfRGJ7ZxauPTq5zCQ5anzQtOp8gHUkkCjSABEAM+Zh00nN9pw20DnIlydWRR1kqG8zd+xfvL1TGtmrF4ZTL7V3isSnb/AB+Ok3GS1XF1me7vSIuGqt4uc+k4e9UqU8od8paC4accqgc+9SY9pGZsdbo2sVs+3K5CVE0ZEQzPm8Q3mdLd8PVGWGuNeTpl+zTlpNoYVgVNvb1i/wAz5xXzHrcCwgCZkQLUEkHUcjDqSQCiIAAkBOem/OHrzl2zaKlsy8n2rRSZpl38Vdj9Ls2uWdbfn9pnO4VuDquY9sFZsNOErWoNqnPo62U51YNZzHVlNRYWrLGRUrYJQKpMxd3CAlM700IJxDOc6j811mTuMKRqFK2ivKvt1zuq3Cq1Tl6L7AFNtxU25eNFE2A6mn8XPLPXpo2Y3bTDAEEXpcPQEGR4IKzNJCUaQCl8jDoEgDCSHqG8+a/QvD0M6BOw3N2Q2jx2qdGPFiuvGLWo3KuTXB1dEIS2rCAcSEZFMqMnXtgtSGYWiloY2vi00nloucX+HYapYsZllq1YmGQZUa2zVMVc5qbj39bq0OdrcDb9Z6TsZYZpgzvyQibP0nqjkg4e4iYadjcOmdzHQcA7OAjSfVgsJCI80GWsiIDCTBZEAMJAKIiB7u2A6ly73hlA3Dl6LE7iHbh3DPJFFHsVch6VoGMcrWuxr2solYWDtTed+isP2AVBteevQRY2FqCqUPTaAPd8b05KMQ1SQTSrk1HukOEcp2Kyyj+k6PZn5tH+il3lcvkV3sna+Q67EWaA0zoyXc1z9aZrl2eWfZOafT85SUk5WEBjA0haLJJiABDUZADIgJakzKa7pIuePp7TsQ45tZuTqPQU5NQvWlFFZmdGDzbnVtFldL1HKnN0vs7zyrC9585b3SgK1Y6eywPYDnnbW/Rmr3FJhpjMMNrHf8m1K86v2kXdKvTMxE1LmarF2Rj+a+oM42Mv1Gm3hXo8fm1gl9u3LpGzl7E2KW5zrafJ+3JVDQXbyKJBB0HINcARKzNJgAQBQSAUaDBUhGuUaDdc2tfn9c9caVVoabZjOtUXyaW2gkq4/wCmixrVe0lSoGa6vCRWz5dqcZK80aZNm3CQco1bl6beoCXeqf1xOoktqpt9TomiZHcpq0smqLi2qrvVyXeyR4HRdHidHAv880daVwduMbP3ve065QFi7debRl4+37z53eckEN8yCiAgAJoEgtZJAlGkDMAAYIAaufVFslYtXH0SFekttHj2m6S859sRwTbqF0Y1OQmofTO/+ivElhD07QbxDcnRapTHLyTM53b6Iyakoq35asYKZgaVQr14v2mbjMdMw6Xx06vaHbrtZuVYlptcX0qLJIJkCY+er8lRAQuu1qqzuTjK5z9uoXDELbxdNtzzUsV6uHOaofP1/L6EQaURADCADQ0gpQIgUEmCgkAZpAKdsgi1OYNXNtdb5nN3x13R/QdDzPMyn0/hrVcf2DGu7hnNU842rszZ+nfL+4c3SuSuFEyqzxciuK5WgueGsQTiC2ytjyrTObZYlfoursdgc0kKrK3WbV1OyWGvvIMhJ6R1gbswRZeVVl7MyrU2y5+1xoNJ1PNd/LOy+aPR85JEfViYIxGEgDCQNoCA1ERgAFAk+ywbAEABKB87iJLK7BKP4Tn11bTPO2k46Sla1fKcNeOL7pJedpjFl0OjaY5PtXn/ANG+3jrGRatScKiihZ8egxnNvjbCJnNB0zyuw6DnI4u6Zszb2uBxXvtlq81Wb3FMjsMPJTaneagOx2/PL0hlJRrIeYtW8dT0CQoeVGT2FWPR5+ISpoGQBRoAAEAZggMzSYAEYAyAOujOWBqrv1Q7mYu68nQ4qEpFS+V0z240r/pGdWXDSdolit7MZqnsHGh+bdLrfansxknj0pd4ib9rFb5yqc6mNKrUfeeceT5531Z0xrrOU9HP6Mr+baLc5jN2an8fT7ClvP8AseG0bmluiU5nRc9u7z5sJWHzuiLmJFmH5/u+Jd/NGc+iOrIGRCWEmBkAAAAMwAMGQAwTwCeMmwSkUDA5eIeS3Uq4q+GrlMe8pTS7W9ypvaatbcN7LLx77Jz1OTV6Glhpfbn6Lnbomxc2jm4Vme2xrtc70/DaeyOn6J6fNkO6cKdkrjhHr3E+bHId6j9A2z4Vu02TPqvjG30zsyxOv+hMad2q0eY9jed/49eeFw0XZa6xfnHUsh7+ZtxWnqySCAjMjA0gwAIDaGXUOYnFhEol1hGFOkiE42ToFWmbJZoqKoW15xy71+XhLRSiJRcki4u2Nmw1KcZ88dJmtXClcvRmEtWrZ1TfJWp2Hzuq0vay+lQFQ607qyZaLXbl1Y7lBRziIyNxrsKlSIu8z9Kna3Vqv0Z2VhBRMVbKZAWtznve80jWdUdUie4+h/BylW0zyeAtL/0eTP8Ak7a7RwPtyaAMDQoGCQYDsqNAEDIAYAASE0FWO19wrGvxN7xtnXdYjePo8+8b5Vt4nJaHusN8i8ymVY++0Koqry3itd5tfANhtND9DDarJCp8r1bTyocNrhC3Wmb1JUGurQ2LWEK1xrinVf1koC2l0455Xr70pM1M+kltsMHfMnn8EhxtPd/3kcLz7o+gN4d121lpFFdabBtY3ztkJ0ZxfTrzuePNaGAJAcQbgG0n2QHd236BNR1TngkZuoOEWKYpk3FarH853h6KFXtDrlrhZKTebm3xMLxx0nG8rJ0lbFnlqccPCnv3y3rMQrKLPl2FfNu1pZYlfrXWuHaAgazypaEqvyAkVCZd750xjEWW1Vek7WGXDQqVdM1YUx9HDLLfnLLon0HUA7wuJbzkfa7Q9jZVMQVkjgi5GWIWdc7BE6KtQF4r2sQw6DaOqg4F0aMAMu7yxA5goXkFhgZXsBWCvzEu2WykcOPe496v0molczUKWhPqhZqUw8gYpK12Ogy1To0fWqpSyn0fnmlUtedUeQwt1VrdA46U+ElWsaIi53QBYSrQcy0mpVu6v9ZgqntMLJmHo7z16Qh2WCs9LychWomIqp9U0yaqNIv1D3hmqIn9J017AXbmukMp1lc197e66m/b1yTRnIsw3nPI9Y68ESXLiKbrziRHx7RygVPxJhJxscaNGkabeuPo6nCx+Okw9ZOaUcykY21bZigaM5p/W69bmg1zXodmVahVW9G3zGSW7NXsVrtnUhGy0ZncyVR5S+ke9rms8Cd2HHWN4HPy/P1okITaLRDSNhh1TSX06kKHZGIQWc7JnlrKpnpG9OV8s2VSmGmsMM8nUSsyS0Z2izwuk9wQi8dWTj0uPl3XwDuwWADocwcxzviCeyHyb61V6b5N5LouVw1jIR8wZ35sOaaLDX421uM3k+h6ZWPm15VLJtZgnR6/rdXTj5mBaS7TCzZS5mchH6UVxvfIMoqV0quHRGudMm9c4GzWRvmR6nvJEdXLHnSp+ruqk4zPash1zoaLnXN4pja2RFjvTM0c43pNdmizfMunNnYQ4kzJSuXp8nMLMEBfUAEgORrMfPsUtI4k2/Hk6bSUI8x0drdxstnHyrHSRI8CQczXmwaR3yyZqdWf5BL3Fljq7EKr9XmHSXfpnKr8h6TqYxum2ewOZqd4c5PTKIY2OvRTxOfuaLa2yW8DqC9GiJIvoTQbyiP6XvnJtoK/aRR46Qb2pN3FPsdLM/r9vzo5SOn0oYWgOfJpdB6nLyV0AcugWHFS1BxWowFlhdFw0qA6c+TrkZPrMY1Fd5OJBjXnbPbNjOvuacfBuX1TX50lA7hLtVQ4PeljacWOEuHPo4loLqnZo2Ih6m5dc9ONLm3r0hc2KIjI3SOtOsGcaRqsDGXbO7C4hH+VxPaVcyVah7VkPVgwkWstSq6J/TmsJ7PuTfS9U+XytxdId9lU6HIuPKo6D0+XmfQw4q6AOR9QHLspxLc3il2rl3rjGZYY62bpXJTDXm3nJRldme8cKWqzeRuQ7lnsVFx1q7ua5Wr5CtRM7K0+LtfDiiXM2GuOqm0V+A5RVmis+e2pyvyXWnONXkwSzOxpkzezz9NHM84S6S7I8i++mMXg+u5P05cnUxTnV4nKZdc3G51rdMHC3lU5JI1gRKrmLEEYcpY9XiIuoDma1ByWsI4DqsfK40mS5trs1bK5N5k5VeWlaeyL0OfN4pzT7al7SCbCJKDcISyMqlMu9Ty1tLOvqKsMJAtNZnK5PxtzZXtbmcbjmd3Q5p1vVYEN3sy0eb15l8ZqrFBxdvm2V0ieuLnIuRp22LHKL1VOvORiZSxRXGwHHRUYmRZqrFZM+mSZOIs2fpyonwjEDM/U4iMzYhRkgJMD6ducxJCz76I5Oi1t3URhq7mKd2HbLLGTOmVjadlXEb2lIKKfTretJzMHIsOXavx1hj89WckxtLKei1NI0rNp4WS88htd1xnbPXz7S+ZWeHCO1mcrdSq+qnJbpoOdQlhuC8yrz5xGmaKc8hds6bP0y16OGsLONzvSq9K1iXwcT1Pz00eTpdxM2DF51HNCaF5+UC5H6nL0W3Adk8yDuOSkOXLKXl2eA0Gl+f1xNqpN90RuXbHnvrP8ecXZJ+qdtcpiCjTmrozio7K3CuEXjqUpHSWk8YKXiwmOkcdq1xa6nUatnvOsaTBabmarLLUXN9mqHa9Fs3PVetSotxIwrXhrLipWar3DCrtV7RWJFNzHEwjDlauXPszw1mERznDfR+lXkjOQi2j0LGJYa5+TRwL0+RwG5A4LgA7huAezcBcYq/s5J15fXlrS+VvQk7vk7zSdkEVL8ujOXrzuLOIkomXZIdnV6Lfwo73SbmWTopa7R6Rx1nQYutOWnLywS2V45Y9EnIdUtVrdYup2t3HifqrI0mZqlndtUprIcKVdkovrrFQj3cbqrCxr0y1XHTuKHYY2y07LSy3in2Tn1me/ThUQL17WZvsLAEedBwL2vO7jgQu5twDtbAhyL+vyCNa0HNrFwdNghJmZ5tcjgd4CeLO79NF5xaZReOlbb6BUpedxWrddZzuv65ZbjErlfprN41ITl/uanG6BXElT1fUEil3mbNSYxlNC5x0G/bXYEvpRycZC6Z2eDb8bkq9eKwyn9bTSrK05lW2sR3E+IPoqy57Glq0vJtBzrQ66iQyce/5cE2AeijzaTIvX4HpMSB+I4gkRHJCUcwLoNHv+T7DybWC7QLfj2uz7M+ed6E3qbtEhyrbSLn1prUU5eR/du2t4SNuNEZV6FtQtzrNYb0E0RMOP43Vq1y7TMilCsbM6CGcyh1EfHyiaTZ0xK5Jm1jaLJU0WhqkOI6fbj4DUqO1B57pdN1iSrU1CDVpmfWKKnpmtS+Ok8yneEjcNgHlUAvX4TIAADAAAA4mIDsGjan51dQ/Q7LK3/JvoUFXb5y70WD9E2UWGy2g46PaYeUd8mzCq2eCz07GJmlmlvVLWuKDekvoJo/uXkzB26oiX1WsFzwkYBoFrZRLW5dOM+nlUxBS/W4r1gRC0mVoqMszk1acxyvJtEtQY4K1hkx5RzHdujeGdydgrt/w17OoZ/DsQlReXhwGPW5CBgCMAAAADhuAm56jKRqh53dMdNPuuGPefXbXeeL5tF166zc1Wu/NrF9qJCw+8Xfrli949BMMtl8b0iFzuC2y2xWN7Djo/Y85PLRw3hGydwbQfWpduYq2OWc+lLmQ4R8bc98/1HlSq8+TBFbdW6tKo+DnbHSrURN1Sohh2b6pcrDKi7vxb27m2aWSCtynoFDSfFgA9TjAAAAAAAAAAA3DcBOWrO7DD1WTjpDk2lpmotufaXb8+8V0g5es0qxBP53ozpthfO5qDkJbjJnUpyum+dV6WphFRt6oPea2uexnQOTazr4rebWOsNI0U6hlF2P8ApFTwpxyIe85oRDFOzMi4sptmzeaVTGc6vQGq7W7ZSenPtL1yQTvEnCWzk6JmYr7KC0iLFz5YAHqcQAAAAAAAAAAAyMO8hGuguM3UrHz6Jko+cw1lLjyVy6w+T3+iazapnhyTk4Z0zilTLRiDCF70Xqy1mkRqrnS+0J25do2u7H0Tf2rDpap0AVSuUtERVrbDl3yDqHdOmOOkrYQtdZdHlXsOdUitarm1PRGVXuaM4p17p3RlDSTedY9uFHvvJ0XxUf2glBEip8lAD1OMAAAAAAAAAAAAAHXksJG0V27w51DfnybvbFXUYauIR7LVNjkEssNKI3usRrPK7RczhrRIGy9NJh02OHa7WKpWRDaItMU1P0G5WYPOk1dc36srXK5Vz0nborL2otFTUpIOtjibhlV6fVKx5VyjntQoi5mIi6I+i2uE3zjH7JFK26Tnug8HVYbNUZiRqIEaR5nBH6fGAAAAAAAgMEAMEYGCAdZGOdIu1tpuo8+kQ2dxXJ0SspI16HY2iX81AOY7lSuzmPl8ry239O4+kLoWXitXCtu9Ikas6yfedWksde7Z6+1yG1xTlqrQMqzue0V2jN2O1V+ozd12jNVIyubywX2B4yUuIkbFUk4vO9HzraGoE7RYrVX5vi6J55DybkBApeWgB6XGAAAAAAAAAAAAAGCAdHLMBcbTmEpL0ez51Pc2krJxPPLSXHVnLiZRiwHIWahXSXzEfIoms2k2TLca+edRdY0WGmqTZL88i6S70KeSzHpc4+45O2K9odipzFS/wzZo65xvha4fVSslBz8U1grJLJ1eibRSwzqZ5WLSZSXiLVzbzLTl1IngkXHkAyHo8xkAAAAGQAAyAAAAAABggCuvAwnJSo9kXyXqV0w0lUpk8dCpWgV3OmNwahkYg2gLWfUSZqnWVObm69aubWUlKnKIddKq2tXWMz+I6M7tH0yK3z07nhD2lsExjN3yq3NzXLpaeTVuwHYM3l2bvRpS1FSkU/TnX8HO508k+DsVfFoCPJoA9PkAAAAAAAAAAAAAAAAAAAKAAuwATt/AyuVfgc+iwBnTyHAio7oBaKQAc07TAJbHQQMNGM0BLhuwCdBrQHXnTIgDt52b8BOw6CBjcJBgJ3JYEOfrQFGf2QDWFtAMdLfaAMa5wwFLQwBWf//EADEQAAMAAgICAQIEBwACAgMAAAECAwAEERIFExQhIhAjMDEGFSAyM0BQJEEWNEJwgP/aAAgBAQABBQH/AKo/Ef8AD4/0Tg//AF9x/wDwDz/tcf8AfP8A2D/X/wCl/b/u/vi6uzyyNnBH/C5/2vG+NWpgyjBWVDu+FBiR/wBrSj7LO6Sn8okJ3oIbrofNaBI/7OknVKUJaVDxpyKikuX09sink9M69v8AsapPxv3yES2Q9iFqIVeLTy002Z7MHjT/AKw5zX4+MQ4I+pmW4nyRTVqM1K8tvQ+br/8AWmAShZdeahsGizZw6YHxy6irT58fufTzeh1f/qheckeYKDmvvVQtfkOYsStUxKa7ZNzC+s82zc1H17/8HnOf9KfPZePQwBz30mdKxdaatRj3qjO0KY+utV8ds0bPM6vyNM/rc/6/P6+uELiZmnIy4zxu11esqqP5nqUD60uL/wBxmS2pt9H8lqfG2v8Ap6P+c/Q/+6Fkwy165Pa3tUJTT3cPjY8vr0QnVkqiv03NIbmqc5+pH0/oH6Y/4PitevyKKSxJybED402EK66C2prbIZdtc9l5M0BXXkitnjtunq85qdLkE4efw4PCrz+A/Dg88fQIcb/VJ4wH/R/h5Pv6AZsDhlIIYLzp+QqDSML4dWqikaFAzrXtNK62x9+tdLS2tWkX14B5JpOzUmAulL2m8+rrE4JFmnDkT1CQ2ogV0/M/0en1b6NWdVXFzn9cHPDsBIfttLgYjAvcKPo8yRTdVcPlZl9jYnafsVs7dK+9Fbfkm7p69aTXQ2FvXa0odpdOaQZNiWos506o6VkZx9jP47iz7cyceZA/WSbMdXwzuE1dOKjZhh2JFaaWpddvSMajOf19OrRjrP3nsw+2i8Hv9fmrxo11r55Kf06y9769ZGcqCezq1aeuFVdJ+Kmcj4+OvGQhV9zZ2KpNPRb3b+1s/I1oWtt+TYLuq3bW8ZqLLWsBW+3ouVMfo0+M4/SlqVeet4lUTnU1x/Nfqve6HWQAqDkHsT5lFOt+PP4c/pAcnX1Pa0tdYZWnJ2R91Ppndhib+wGB+RB50fLaC7Gto6nRfyJLuUKj0FM2ZFslTVR6bs0yu8Cy62wk9hRLdQlIzSzKmv8A+Zs3fX1tBtZnusqT4NnPjeFrrEAj7ePw54/DnOcjKlX1vEziD5OaGm1QlHdy0teeL1xqFGNzk73JsC/jf19JQ2zr64iLEvQ3+t2By31IB5cHPHbDo/rDPN1XNiwmHcYtEzbNmXY+RWm6hk7yv8XW1VXGVV128PL1V9XxxLvVRSq+T2FpbR00fXS5pts3Z4bVXA6yS3jprr0hVHabAgcnJTeja3hAZpbX1hsbg4RphNejHOpUAJ1fqhOw3IXnE45X8rx/P6/ik77jrwdmPOGp7inImhoNbQasraUTDT0gL6GxytrCsvI0Lah5Moa9OevSUaI2zWySi1+U1JbQrrS+PDyFgsdWP5m/pprrra0b6vntCxO3NBHxJEt8fl00Vqmpt/4Ibc0Bvq8bb6hJkzmHhqFJVhrgbRrl9ivu+HamfB4yei+JNBnxpDKwmq0j9ehyc0NPL7Cy0f1/4eVDtWV+XqmX1SKzjRm8bpjDNeLvILeQaq1AsmgfdvxNE15iUtuwTNVPdK2vOSvMfF09cTyzLI7m7ts25sU2XDxGxTYpsvCDCnzE5kGlW8xreQmVC0qy0qEELV4WKbOyf/jpTPlaerLZ8qWAuuS3CmR2O5XToXpLq8kTiajtGE8fVKnY12wkAacpVPmfIHYv+v4vZdLGgZbQ1zYM5bTISv5aC1+MGyhuHEm2PHhtiacQksyvyp+v5htFrmBpv++u3s8X109K3KrranfaSni11mXi6MqJTx2wriuvL372+0vIpKO9taboI2Y0jCo6t4+LkUXVnXd5au39w7pgqJjp3EdQYdGfEkm80hp4KSXG8i4ynlaYbl8PfnZ2Bq6RP1/Xk3DzpzMWL5M0rScldTQgCasldAmGohK6tZTTYv015bChtyarbsJ6f0ofJOKS8cpes3/L8vT37Pj5Q0odmNqVnGVh21PG2aG1FnWnndTY48PsVi3j/pq6Wn+R8HrcVgNaJTYnuQdSn0aHKL8tgy1gMju05jY8rVVICsdialqTyczipmtJKU822u1P9Bf3WhRNblmnITPylZqU/LWStTVanXf+ubbtbZts1V32XMUn30b0RhCxs3mJNKfim7T1Spbaok9zRoWVCsnSDBdlQi2nEb+jsildxp20/HeNjLKu8MnX1z2be7F1+yTlVbXVObeLYTsnrePCL79UnW9FFgyzyd5svx48XX7fvcpIDJ8dt/dnqwd2Zv8AQlD2ZPVmua4RG2bUbJOdfEvMptPaOTv7hGoYx0DC/kABeWoV06VdZM2eGm655NeyaAGePOusPPRQ4y9U6qXSrPIMRsV8SSuv4nqN3dVYwp1zuhfYn7TJFVryt7Y0dI64jxXssNnXE8PKZBVY6+16slt6lBsRjy9IsVLccfVRziowz+INuQb9cZr+omSykJlaNYmazbhaD3ZqzIow2FA+rvL87fdQvmFV7eNT/wAbckFnP1s2hrlJeTIWWsGVfGKqpvJS1/JW9zaxJL3dZp41Dq2cKm5tDO3yDFbSyfjHpJI0Q6rTTG1u+w8JLPR1Zdu/3OklG5pRGT1lLSj9gWPKPRM7c5/6+uasRyh6t5Hba9/w5/W1wC7lemkOVrwWVUKfJpKuts9cncKFpJ2prQVm1u58jA+/wXKavn05zxklraa/b5vnpra9EwtQLbbCDdkIS0ddY62tNKb94BI08gssd3uySTS1abaGK7bie1cUhqL2YXAysVAEkVtShNtv5NF+IwGrDRd2idc2mlTPlQMUYsScROo37iGi7sx/0Jnhg6sUZvXrr1jbyo6m9GpphXMYr0d9Zclv62RYzFPH++mnPqfOq6r4aarODfbaIqw1ARaPsbZ1PbtX1613N4suDQnPY8lfqtbszavih7Nt07yr+dHnZRk42l3ANhvIOweFzaaMY+tUCV4ba11dficrJ6MKs6ETIMpk5HW4w8DEZc/ifYJUn/Sio6LWjts7tkWWrStH8YZ21NWy08xTYhN3rVvVUYmzsTbx38RvGsWjtDyU6GMWKquyhadQMmeq786Z8jvmiWGMri8Ohr5Gs6Vj48tSMUQeWoRTXn9dSbe2vONfV0FntEn7MjYsZ0X2g3R2HtHxul9mVC6liAoXJ7CZKykbbFU+938tcV3P9FPqzV6LMT4CN79FURK6cykYFW/iappsaMOsmXKcAQ1rbNvH+Q2NC2t5mGwu8MvudMFiV26ES8gj9tTXUSqg769KPl0o2zPQY1WEcuD08l9+3qAKsdIcUpOZ+OnOt36R/vZZyWdlOVJ4jR2x9VeNv1qKj1h9gnI1+uu/DbXHqvstHWLcn/Rk4UliRYp69ODBdF2DI5dFfkb5JEIL6NvTSct7jv4PyHwt/wDiO/jt5NXYpF9Si7Wr5OPC6NPpthaam2D2jJCtjw1C42tlTeBKEdAq7fCijmtPHapUbzFFZr7LQ1Spcw7+yyqF2qLDWVEO7JMV6C0q+zNpOBZWo9p8Zq6xGa0Qx8jMejyu0tK/6cT9aDsy34zRKMI0IeZzyET30pLbU36ds32JsP39DKjpwP4XbmPkNdWh48FFp98m6DYhNOLAHKPzhtIKmz3IuozyN0c6Gs9XJaS1js1pq6jetUTj4ydfhqElGNZ0lVMmxJoi5rvRaX2mpm7QLg6IAGo2lr5/EXkiiknn/TkQcSSexkPM1YBdiS1nfnPNQcZ4lUSnk9XNjVpRtTxnTKa/Ubf25/Cg/J21/K1w3HuY5Z+lZjKuVazv1aHtGv49pgITh8YGxNfqiRbHFkb4jWb1twsghZHYWJw7TJmmpNHKqJfVtxlMtsa/eCTpXXk2b3mPQt71s7fv+p9MCE4Y0GH6fjzjDIFgeOZzsZmG+8qQoyCVFum94xpNDy4VU19RlNpTG3tp1rQ1p/DQ4TyNR6lGcd8XTDKlFJ+rJEcjS8csUqqDNryEJO/8RayZ/wDLJc//ADDZBj/GG1zDyunVddqPlIk4oIzf7TI8hGmTpCdZJFsJIatW9d9V2YS+++62utWLsrcGhBf9YfTBagz3NnsTB6jiojCOuhxec2ZMrTrRkjsNxC0JLHbLvfxULK38KVz+R76DyPjNhE9KrHweyqTRi9bdExU+7XmMohfJovHjNNfY4Azz/lhrRrsUqwm5wjP4b/h/xm7o+d8Hr6zz9k20/MbWs/jfMR2pbFVy1F4PC119cvilRQ065Sa7AWP5voOeQ47MBh/0VUsfh1GeqGD0ZJo9pdetnAw7KMk7KjTaZTSE+KMzH2V9up5A5/MtZs8pviybMWRdDXfhKFA7dsjEtX4naXDqXCyGn1RPJeRWc/I7jX2NXSBC6v5789tLyWxrEVrszbS+m7rlU8J4pitGPO8OMTUByUDzJwVaTgIei1ovKB+fLwBVxhH685O+f+OmNt2I/CLfWyntLZKrXZJyf358SjCevfrrUoF19vpFffU+tmeTNSW4VAYu9mXoF+8JHkTl98VCJu0TvtV+0+YSUt3aptPsQEm8WErHflw29IpbXi1X1ZcY6tg0l2K6MFXW20FE2vH7PaW7dDr7/ITYTvsE4lZ5ur1yP2NuODGiAM36yqoD0Zv6Ub6uhZWjnqfmf2tr7jIH8iA00csi+0x0jF1M1xqETMS9NlqZLvkB9CR1RzhcmVuc2j9lbUL+MrJJ38Y+yNN30tisZbEdzxz9dLx5IjrdManLaOjMmzjo1U5fow8l4lEzvRG8dVAnvdViVUP68PWZ8luvwz/rcBc+hPSedEz1Z0bOrZryDH4/5d06NIBsbX5E/tIn906gTnw1EjuoUexxpHnyDETnVi0jy0qcJOoxKIwd2E67Dc0ZWxpcV1Z6zNpxUp5Lw0tlfV5HRP8ANecXyP1tubTrpaFnVPTrLuXgyzf7djycY43mVc7c88Ztfd7yrvLsyFUzaooGw7c9Oc4w/oorMfg2GCeqmd9IH5UBn8xOfzJ8/mlhn81qcTeLCNokUbW6bEecVvWV2FIPrbNcMMDdsSXONToG8tKeToaDfB45C5rN9E7gSXrgoozZY9LXCnV7HYtBBmpsYl7qn81ZEPlNUimjpVf+W66mOpqyDeSipfeAp77vj3oJ8bNzq+PaeeQCUl489Mq7Bo1BNKy527pSLS5RZoEYjnjkleP6/ZJcO1cj9BFpmml/W3GXGWKZGgVgqUWOmuL47aGXbysxub2xNbfH2E1Un18hrEwWpVtXYLvqVJxB90lApvgoNirNnidf6bevTF7KIzRsbVbHCh9fXoyU+UjMdsY23SSfN38ht/Uw9rrSK5GnOeTrZRpkBJgHKr0wbNOyKHJUdDKzY3jqjDq/a2dfw4w/oy1r1z+VbQz4OupCeLTJT1mzT1Dy+qTlYIF2thZlvInmG+CNfyAXJeYnwnkNd82fjWbc8XO+RptyqkuU/iLxJjTxV1W/qRgNcoGvsTr5DyjbD600a+rFUBVXxtZTQy6EVANanBxwiqTWc7Kk7Kxu2e5FMXozT1Axnqoo8xZ5toIHyyrN6IFTZQcMV5OymDZAyS+xduqvKsuMcE514z6/hx/THVrQdNRMXcPakfIPgTxs8XciG+f5CefzF8hv5OzFX+7K+P2qEeA8kzL4qkMlKYyd48U8dGzW8O7Psx8h38fs7a3ShzyOslob2s2vsjfITb8uVC+R3KNLxO7tHx/gvQTL7r3XXWO/Czmnc9pA7WmM2NOuaIW4r4qqvsa+z2loWOR8SyjU1kQFyj32YqNzs9NLyEeL1JStLNnX69VNP5cQazTGpXpKf0V3JSA4OtSlaxkgohGHn8Zzd25hPONjZcJqTw+Qv1/9/GWYbbfhPG7RX4+mmTpopmntUYPtOMrs5auxTJeL8gSNP1BxHj+WbfIvWWfPORvM5O30YqR/FemVf2HsnW58R4WEURQMOXp0SvldO1EXx+tZaOcYNw2y8mcNRWmQZJsmbruhWa0zr+SeSjycrJ34nvWLhtHYxYV51NFitJY/rC9wD7p5SmuWt+Ys5sXrqKjQpTNqz9k+uWQjKyoc64kwQ9Sw9U5ZXYo4yc3dxr/HHOmh/mNwHZmM9KhWI1kyfy64NOgHfx6FvJ2Vdna26ZCM9fJ7x5p2o8dwKO3tw/R/k2BXaoM8lJNqCeHu9fB+H19ReV69s2bMgp5AKw8boVOx4CLu/iNlj8Xc1p226Oj7tFF7OAu86su87jb7DNQUDeMn9NlX9S6zPlNaaZRddzWwAP0WnyGm9SCNlhiEHNaP5ZLcWqVY7nbH12A14kYdiHOylKrbWqr/AJlX9iz/ABhrUqW2E1MdmZsGqwA2Unk9fa2WE9XXY+R2KKr8HsvE4vUtRZY8Rmmrvnvhw7M460cq4BndifkOHrulEjudnXYbJbWfOmgF4USujCq72js9JHdkqeYYVlsSsu/onH0hh0frPQGJoS42vHArqKyW8evbJU655Wk0x3NwNdlOrrnjYM1L65635bOq8y9XMpvxKqBN2TMunrt0OmoNNeq5TohTdfrZqF3cBfwRFC/K4nk9clfes8RHpSKa4au7zkwhyM1GPBhk2YBqvwWyOp3zbs12WoniPwtFPW02wTZrUtTtt9+EpwNfaDYtvtX0sFTsBrsglegynkpK3/i1X4xx7UV6LVcoWGLY8o1ita0UbH3U0d6yqd6nWlPprLRjHWr1CtObrTnYVGWs+2MpVtYO7A0OSrLGeTYH6h26tQ0ed0bsi9cLav4ooxmLFEZm/Klju7sidiXLZVgBxgzXPQpfkUNcYNxryHXb2Xxh0mk/v16saTcPhmufH+nxABXTY58M46Ga6+yy5K0nxKMpO44xtqbFmjsYnjuoXaeeWqaDreOT2IuwVHB8lBK9p7A2oRaja9RkpiohptMoJYtJTFbUD05cOkJpWiMzSBZjST69PutuljPZZidztk5fl+7gVoxwJTn1A/gByWPOJLkNX7cAJNGHCfZPBzgbJ0OSZiGOQ1++dzzHo1DXu7n8tW6rq7HXI7KnA2cni6sFpIZaKlq65BE3V0q/U0VqxHZYVoASGV4CuP48qWR0yqa7YFDmu45M/FVRdZTZF0Zzwwm4dXmHU5enbE68NUoFQfFvNlekyuGDulVcFS3KfTNW8OtKKVHs5VWcMrALdCM/ZeqrjuzH8B9qohZqMGb8EAbEkMmVGBlOVpxOv1VfonAGcgjspxptzqdorCoINiMaozjtj/XOqmbz5BHDVViKfvSAV5j8uLspNx1DyZPJ6FJZ/K6PkdP2Sh44Qz6Z2oHeZfEPAtsBFaiGi/2SbijuUSmx1eiT4aiqatVgZ8n18YlEJXYkq0m3E4UI6OpZQCq8nt9f6H/dTwPxXJ3bFohyXQsWBYgZ9vDgEcYv0xeFDsWaNypXbBzur4tftFfo1iM+UACylX2GLrdfkAFjr14J2G4+RsrWQKtPjodRFVlGOxUyZKDuFyjjq95UzZlRa9KsuvpoMPZGpssZU2Z90ZGFtYFJlQKIc1ZIuCQDr9Jzk9cnOxPxZHG01J/9f0KPr/THry/GAocHC4j51HGFM9gBUjh/rnB4BIzueUt1CbTetd7gCvZu55LHjWn7HsXeu92FkkGp8LqoRc4YZMq05WOPNHxmXrtM80hvjcm+++vXXrPYCuHH2DGqrH3lV92WLu68qz9Ka9OyH2dcUzJCuMnsS5mJ56mQwcjPi1fD/Sv7/jxn0ySoQwXlQSVVs9QxZ4OMdWOUVVCB+woMdpjC79Q88kFI9XAopA1a81mp7xmrHU1RwNVCm0iDOJ9flBG2tpZ4+2BjbbCmxbYB+TSsvcdhD5D2ZTYh2+TDbjPRsttTZV2pZfZ7OH7NWRg4kOopabNmpRvXeR9lJDJyTHg4zWVC3qiF16dm7sxmNojjOPw4/Afhx+M/7k49dlftMEmcicE+AXUB3QZXa7Yr/VI/Ro5YYIfQ6oOLLrmsfu8gR7NfX4zXUOFUY3DWLHpvEvjyuMrolteQd0TWcGin2LTtmvtevLTWg39I7GNMBtPjtDpVHUzIb2INctk5DtuHrOjQL6W1NXtQZPtUus0hendvsM4XTr0JyUZ53UUOwy/0cZx+HH49Mj+/3BLGmS9nKDrjXAzu7H1ls+IFCQVR7EApsBimsAWUtgmvDJijrnktbnNIvgrMYqBUn1ddcri15HZeGPUScB2tw9iXClgdyfsrqu8rVgUe+oeH9xLXmcnVdlYhSJT5C6wRt+n23KlPRRs+QqLo212L2AGxODSWMvYs0DaelBzdT0PNR6iPx4/qCk4E4xa9SLFhXryGwTzoTiTUYHUY3U43dzWZzWhxkpL26qzDhXhAMrKvt90npOKEbMKe7SY+k1oaVCTgLgN7FV7CmPTjCO4ViqnrbGRhsDX+6ceUTtE7CKRXYya9WILsdhZYlkbNjal3vWzUTW2ZjurbGvREe14gTE6Y0ulptNh/LJObG0xKrZ0if01ZAY0Th/WcWS4ozpnXgp1wTDF+vLIC8k+h1/pKP3nmlvWQdwBYpJeutfBwGVZJhJRX2Kssalc7MKD9tiX1mCMmKqdf7mp9MH3pr2RxsmQOvsS91teZM/YDC65eZOU6gbk1otnbvOtPWDy0Io49nrRAO3uVMnuVdqCpz4lWFrdMTWcj9DjPWc6sCq/VZuMUJ2RxhV2z0qM+MqYnamGWCHBVW7KCWovC+lxRu3Td49YiwWFWU2BMvzWwCnYJzFpDp8g+uYLk632/GAmZ9chMBZhCz6vrfY2+qaWzd2lCRLB2HQcClCZN7BvFVOveIo83Sq+nISDH4HcWmVYCqGwscklCZbO2jvsIR9Wov7foDuc9bY8xmrZAo7YS+JUAnZnibnGQ0qUwIOGUZKXY3XpkE6rOYwKvfbflXmTOa4ddFpaLIp1yHWKq/o6uNNXnsQaJ12myr9crLFbK/aWdKTruvMbc/wA/V0xTK6hFoyXn18qgPr+i23xcMILWe3P2RFFB1h+ZfhWq+BLOAqqNYnrSPOBtjE9Xs6S/RCHJzAx+OJxoWCTQVtyU5JWY5i4iEqWwMOp5YKQgf+4t1S9asqALIurYth1oDHNp+Vj1+OaDAilbyf06D8ruanK1qdS2neboVVheiKvzZ2jtXr01Xr7E1WbNfTKH43ZGmALAAPsqFvdCH2+YiyK+ht9lrL3T06sRRqepKUwyYJQVZtX5E8nuWoLcsdZZKy1Qj+rnA5GBmODnmc2K3XrkOXKRQ4B3xEClaclKIma6+yhovezriEduo5fome76+xVMaKZ7h7sqoFmWzZmGzVfOFyZZMpU0nt66bGv4ne9LruNO27ts+NH8uEXWmpocmeoq4q/Rq8I+2cWwK7L+m1aDKdX1aWBXWj1zbYg6TEudodo02Ti8piOxeUe6DXplGIyUE9hduf6Oc5/Dn8IxXman17YUEGzNrgcPsqs1i9MCnhIdcD9cVyuVYgJPgSLdmdWaKM2FOc9Ryij0p2GbAIFeccFV96l67onsnya9dvaHteY2FIb165ZhLXbiWiqhYAYeMq68zqWMqyOCarRnE32qVZ5MVOpqvRuqKNy/K61MJlXHh0NAKBZLktW3E50JrHoNSa57pLnP4c5znOc5znOAjNZ17B+wpDtl9ZlydVTNRuzRb2icucKKcP2gyCKqck0GIg71RVPkNicxLnruUUStcT1JUn1+YprbdK0Pk/ZC+5WdLg+uswRryd11dc5r66F/5YqtFSmftntxyWDq5ZS0XWaPhYSbckjM1HFY7fN9ao5s/bLhXnptMY1m4SoYp1OQSaj1TLOtZA92Kdp43sJznOc5znOc5znFAOa55zXVFVnZsrqDH1Tit2yezSr/ACE6jaXg7ZFfaaCrqJt+Wpt1HyZzpzzOnlJpm7tMaU2HeFDT11Dl6yZrTmebaXsWXjz0Gp9YaQVpyUF4qTjPwTsoT3cGU1c1RmBkVNVK5Tu6bYYZRGXBrTCSj2TkENGZPKg8L07K2a0JMIgAzXph3p81qjr+YhTbPXnOfw5znOc5XOyZ7MnWhzTPYoVGEFsvHnNjWYoI0XFai5N3Q+0PgFBlQ6FRy+2C2et/ZabiK6Ts3wGLroAGuv22aaGJ45fR8VUMF4QJ1OxILkqpRS3TL1AC7pmlH64gR2EDPA/bAXXLNyql0NJe3NwNN68nE+OqdZNWk6DGfEVe9J1R9pxxq7KnNPqcsCUKUcTrzlUC4dlc5/DnOc5zn8ecivZobEorPYtfIocnEcfEZ3fS4waSl38auGPXNGKkuikWgwBgeLwRVGkzMutFEaHDrFe8xxtMgYSK+vybFWk6VxbcL7Ueevco5uxRzSpmhqkVvgkEzuyrVuV/MKo1VNfZ2t9EI7PXtJJmSrE9DczmbHieruN3GyhFqctoccrJeZTGLOk3pSbJKpYPGPPOc5znOc5znOc5zi1YZpKuRzXqDgKjFvIZ7lIDKS55z98oSqjY5YzOR2ZcTRmpR1Qde5Ycm9VVbO3w9DeUz2Lgpe/u1gKNOG0xpqyaa2hxkU+lNbgyVmnw+V44P5eetMUdmqEAmGWexRHSiMo+3qwlTOspstleu5GPCwbh6l8eQcQ5U6O1FGv/AJo7QONC5yP0cyGds753zvnbO2ds7ZziBjmslhmnJioLIG2Dg2eM+WnM9rXXG8jIgbQY22CTqKqT3thmWarBo7Huvd+2azv7NnemmvvbKmYHeCqyj43ab/R0mvSep2ya9CU5WPGcFis+GbtgqrHplZAhimLfvT4pUljw3+M316V1axA2KSosZTXKz5bZSk3UqyMi867IHQRmTsIWjroM+zpL7g3AP6C8ZMSOaqz5TcKA+SbP5iCW23OUs+Uo2dL0bU09kD5M9dNXZF51H5t+vH1WcVYE896xLYmuudOEbUXmPCVuiNkFDYyOiqy1B4zkDOw6sQMpULi0Rx8iBNDZcog2JRm3FOpPSM6wUFdrx/fNbZnIvsa2VpPpYljt0DLFUZbJy0/sz8kheMWBKyLcTonPO0f0gxGe5+EvQZLucLpiDuYeE2XyXhJLi6MUG2B0oIe3XRURlAOwyBPaGD0X167Jyy/YtQEanGz7iH8izzLXn63PXO6NNn9VxRSPoW7ntPY5y3DJEu+JrpghVRNSH2Vj1ZdYA7Eey3AS222SUVOxBvUSxms3fHnyrS6YXfIFVzheRFuuqeZPbI+s5Mt1/RVWxFyXqGB5YGlzqb2soby8lEvLq2V8inXZszZLWd2m9ZoGpll+2TKX3N/83U8n+WaLy9AW39maufIJ1GytNZ5VWOpZjRtszylp7CLcrhombF+mPfqOzUWQqxqylV/MSm50zYSdVsbzfWvAlxGi1jnNA2w7u+xF0bS68bTnmxRwkgVlboV9VW+1sQU7JSk6Q6rj6x5/Um/BlccOA2a0fqvyOqJTn7AO6qPYMtuLmxsFDK/qDNzk05JoLPJn5tsd8JdVRqJk95URnRHvqzdSjZHXboEr6p15WMwG1W4DEAqy9l21Aa7ca4Jy+mjCuvJRSBctB/ULHOy1Z4t656zrlyzUaRnikDBsKRETKgjEMitO5bXurAyf9Tpk4ZH1gzESqbcRibDua1IBbgmVHzYKgXd+vTsz/fix+6aAO8CCjKDe3L63LLND6hs09ei/dPG+RCYrS5+P1P2+0ai9qSRWsoSr3AxxOeUJZgypiKThICa+3HrWw7jaDZtd6ICsnTT7C6UTBtUGd+UJ5Ht4zWb6SmwDIONS/GHZmCd9R+qM14qTOYOGcBh3oostoljsDiX1wxByvQEOz0XTIkJGaTD4IKxrqhF9JNdPXDZZRE1mnacMlzN/mvLI+URsoi0lB26FRVdhaZrE+tmouN7QktftMerqqkKyROU7hlWJX1TL7c6JbWv1z2W6PNy+xI9S7DDZhkyCIuwZByfg4mp1Y6i/qjtiezI4TyOPr3iF0tbs3Tk2dUG3sUJ1dNUk91WUIe1d6ACSTrHdYVtsz5I3vVsV2ZOfb0o6rFdp41G5rsM1qMrR2O00ZMLlKko7XCg+vsEiHSeuVy2oSLBSIcKn8xRjGy1FOuxDa0SmJyuQunXemgVuFXYbnJ/v36ZPuZ6q9hFjx7YLRuCf1BxinJ4OSPjuc1lmmJTgl242UY5SS99OXdPIS5x6hBusempUPFgyvshwCjk27d0UEP7PUYN00VV02dGdMi1teo3KReO5K6NumRWilJgSxPUSmwHylx2qmqTs2moDF8mCD32XQfJK0hbvqIA6rHndHQ0qCFfjGWhVrDvqKrYslD3VAEnrFf1QcShzX2L8zS74r+pjsNxNCi32iwWY40PqN+aqrBqV2UdxAdYvLjLxUuJfb8b6a2svb2IybP5dtwcVn5C6tsCdpNr8oqUnV9o8xZgvyTF/kRGPtSbPk7Hb5MnzqTmvLq2sUbPjLN73WbHYU4bKW+QnTeopFOcBUYrupipJ1kUksBnXmff9eIXJXkgOw1M+mI5XOhI68CWrxms33bluaTmEp8dsM+U22PTYp1jqD8vf59Mg88TXKvrs1CJeySR7z0w8ceMK5teM7rUWGSfhjWyNJqc+vgyqyB6o+RUDJRUjV2Jdm2KAXgPX6FmHggNtd+rkdKpnRTgXhtdzkHz28MnfisPv/W5yfGTP0SRKhOAXJyS/RA2FlRFUcWp2rsgosCHYo/XYkXppj7bx+mwAsaJPPtUUokLbG9CWwnkfWflDvPYVm2PiUz40uKaBZZ6ZBGhyT4z6nRabU0FcNr70UnbuZL2Z6GePyVdLhdfrxsKoyoII6kIRkOjFIsHEaOIUXq3v5/W4xWzS+ra7dss45J5Z5mU+xmnrZsofytf7R/ls1VTELdKTHu0yEOwDzvbHMmfskX+m444qrkj2er0chXv3Xa7Z63XNdk6xK4utPNiTUS3yIpbyUOKlWwVopnTYk215B+dZuGfYDhyVLFGy3dKKx7Io5kRwtft9/I+hqy3Q/rAE4vUZGvcvudhNSc1jKGXuzZCJ7CtGfaP5cue2sVVU2Pv17N7WqTfnvs7Wz2G0/wBRBkjGf5d5BptHmnxyDrwVsTU7tTxpVl11RUkZ4rIw9o4RO+IlMvpa9V2/HTgzCiZrtQsU9zNJ5q++jhah2rqOVsrKRiHNQ/SLqHiq8LGjGdlA/wBANk6AZKzvhfsyuky1e2F1nOz9i3brt04kgHec267P0wkZsWxZctS3bIUPSfXNeX/kJqqcTT6qkAHMucLetmUEoARbVPExso3zGXPZGg2HnsTtqK2NqWRvegb5gbJwmzppjlSozbn2z4vbERGSSdWWSO/oM81y/Jvrt/pA4tyANtgsm4EP7geMVCuFM2Wbto/YdVjNUJBeo6/+i7HC/GJ9M5HYxTvL60V/tjtLRV2OTbbiytRwG3lZn3NiY/m2s2HfZQ23JiILRVg3VtEA7ZCuqrwrIA+xEZLb+9r61mp2nTs5ZPTTEoDirsAy7qaq3f8A01OQyS8YHLOR91Psn0OSkPWW5b7VVkOH78efC+ztWE26BuV4PSHIK/SnDyrcN3s7gpdkylj2+UpDXsMjsKAeM1mtOU/IyytkObM7qNYumdmaexr7CGHdRROMpLnIKxyw4z0e2fsIkLnqvKj/AE1yH7T/AGh/dr/37n9jf5Y/3Q/xD96Y39nk8H9kv8Cf2z/fX/xSyv8AeP7h/wDWH+R/22/8v/4r/bp5q/41wf5X/t0f8m7h/eP+VP7J/wCHX/vb/Pq/4aZD/Fqf/X//xABIEAABAwEFBAcFBwMCAwcFAAABAAIRIQMSMUFRImFxgRMykaGxwdEQQlLh8AQjMEBicvEgM4JQolNzkiQ0Q4OTssJjkNLi8v/aAAgBAQAGPwH/AO4JRhjM6KrCCP8AXZfMZIsbdDtDmujtLMAnI+Cc6xxAm7vH+tgEUXR2ToP1RRa3oOeirJp73i0oNc7PH1XTsGA2h5/604kYV3qQZ4rrRq2qv2RJANQ0z2gwiQZn6qujtcCIUe6cP9ZfXcFOJ1VO1TAPBbZkHIyCps3y0VgprXZ91EWOxH+sOyM10UwOIX6uxbTSTkHDzRa4w3RwgdqmzMxl5IBssjLGu7yXSMb95Z4DUaf6vEwqisrCFHVP12qNoxqFjHB3lVE0LfeBV8NdHvDTeEAKmDJ1XT2dWO60ZH/VxxWyaq669GkKS4Ob+rJRDcf2lS1hjuUWlmWbx5Jt0tcLwh2Han2Nr1XGIOjk+zdl4ZH/AFURiqgzP1PsEHkpmZHaEXWTqfCVBHFpUmzu9qIY/ayaaXuaFnaGHMdB14lNth/csutvb/qu1hmmsNYBuu3e25SuWq6Sw+8HvWbqO5FXLWzc3UGsK9ZfaGNblecfFXbQ3HHB2LDxhMZaEEuOzaA9U8dCrNlq2LwMn3XJ9mOriz9p/wBUH1KIbhosF6rHonfqrZnn7qaLWzL7P3bRtTHHPmsnO1ivMI9FbFjx7pMeKi2sWlnxRRSxwu6YhXjD2478aomPvbObu8af6ox12WnNGuJxV0lf3rvK8Fe+7fGJs2EH/aUSBagTUtF9vOPNXrJ7Q765q5bMDxk6Z7HeqO2C0CoNHAK9YvvQKsGyY4Zp110B4II3mn1vTX2joIvg9qNswDo3+Knmt0A+yf6x/pDzjSoRhSsFIvgjNqAe8Wn7mw8f5BXm3Z1GK+JusmVsv6RoP7i3gcVBZjgd/kVfA6zaiojeE/pYJJkEe9kUbG1Im7SdZTmOFe5WrpnABWQh1SQ4xgVQGBWuajMkDtKeI1AUqiJ0CJ0A76IRApM+QRG/8k/coOKGw6u5T+SdQTFD7cV1XcWhEAstNz3XSO0IPNhbs/Wx1/wmUA63vDI3C09rSr10yPe97tUzUYPZnxGqDulrmNDqhe6pcCBoRiOasySBceM9D6IEH7xmfijAiBU6JjLWYE50Ks2EwJmMBtIvaAPvC1sVq1XLocXC92miZeaHPJcPQqHNDALMBu92pTWUrIOtME9oODJ7Fq0a6Ep4gbTnG9ulCRFJ/HgCqY602RmM04XQSTWc1LWgVxiEb4B7KKLgFKfQTgXYYa/kWnImuaEZ/wBAFowujA3tocCpsrQgjrD3ueMhDYvNcYwlFoJYcIOFVN2Nmo5wg6C4Y0rQ0qjWobJOponGOvaACmCdswHCm9faazV9fRBgIdcb0hGsfyhdFLhg6ZXvRPs7EZQ3WdU1zoDw6d0AU71DAW3WnuVg92DnwZ1FO+FswGh2W5OLTdtLlYpSsqztKm8Be4GgTGNiWuIGmslAudtOaCRpKechQbyg3M/hlzWOJnAIG2IEiqJYMscXFHo2EnepdaAbyYlCWhwGcqW3THaO1UI5lNeGyc9OJ/IhomGjayRa3A15qEfZIJCH3meMSukG033gCDdKhsFzRN17ZDgPAhGGwYcANJ471BxDOjJB0VnOBr30HcrIsbV1MKyaeSfWvSADshXBFwm42upqeSY0QZvNd+0/wnFjrsuruaFaW0Vb1eOqL7R204Wba/FiVaETca3pK+8GmO9H7QQYDHuDdC0QEx75l9qI31xVm14gP2T6r7VtbcgNGgGatHTWGXa9qe844kZ6BdFdghzncNVaT1ooBrkEKYYrn7Z/ouMElNNqdo5J1nZsIA03oZ60V3abq04qgrovevauXvTyRoSeK6s8pT5NRr+QswfiTrS+a9ivNcomVPsgLBdK0w3C13b01xkXjUaHBAPgOPeRigIiXRPHApxI6t3mWgkqwptWjhyF2U6Lw+8c+RuqEbFrJDHgkfvgKauBbBOhna9FaWrz1ousGea+0vIBusuMZjed/KDbQkvF9041GKc20J2mtkZ7KZYNjqkNOMzRHa2bIdG2DWWjxVtaGl0tAOMGJorOzJ/uQ5x3XaBWT7SIFnIGF52QKfZVI6VkD9I9USw++Re3DFF5Enbk7z6BMvMEAEkefNEirjUaBXSIKqPZKutElB1s+5qM0WWbAxsSfmVMUOYz5lEhwvZgGVcy3UQlj+dR8lAtHDw7l1C79X8IgAR2rNQHifrVWxccvyFkN6ABpCkYp24+xwNCMDlwV6C20BiDqMEaENdF6MWn4hwRY+BaEFrv1EHFdG4zdmDjgnsJhxfNnviiDCKlsg7hkVb24Gy0tgbogp8iAIIn4c0Nmga6a5ouBq6wsKbzKdMfFrDsuJzTW2TSXNYIzzX2d9Npgp33kA914iYrXaOa+0G8AW2Jazial3grB+GzAPwZHx7VaWk3Zc3lNOZVpZskNe6aawi5jZ6NuWZo2ia6zdV5vNH6roiOCE3p6NxeTjJC+0PcYYQdgViih2V8urEJjcdoScjHki6JDQrSBF/Fx7U52rYaAhZ2YmUDbG42ZOsINsWRIALjjROLbN1o7KSAOSAoDMXZmF94HHnK2Q7/AMxYcg7wUTe3Fwx5K8W9Hxqq4cPMKQZ9glwHEkJtnDjfH1J/IVid5T75AaMD88ltxhC8VsifqFJweI4ELe3NS4CIr4KztG42ZFdy6UbN9ri4b2HzlWYczZDC5pnMhQyDMDtoe5CzFQGtl2NcE0umDj2z5K4S53SPJN7EdnarR1A7a6M742fRdG4S8Q+mbne6EbRraGzaHRWDMO7FauOVnB3fUprQIJeL4xuzgFasDusWhm8yrJlm3/s9k0lzpxqh0xEXQ+Mrt8eSdBDbMWA7jkrIAUc4zvpPkmMtZfaNv3Y92hoto7FpJaeOasHTQ2sxqaBNDnbBe47yBmULrutHbM14BXmjZOG9BtnJiqHTW1BUxRRYWdfiPirxdJJgDzUjbfWBkN5QN2Tm458FDWAA/ET81IgToQQrtpDTxhNkgOGBIX9sQc2lbBO+US2ScwMFJ2ZyzWfFYyPrRFo6jaD8gLuKxLScx5rYMPj3RsnfCaz4fd9FexE7XPNER1jNMnKSJkwFd9x9nR3PBEgyLokaDAq0DHyx800MT3pr/fDCBpSkhOa3CIHNbJBN+D+0aprnCXdMWtPJCCLjZE+KL2uENvFtcTESvshaTNHHtTmz123ndivOMAmjnY40MK2aHbVo/accmjPiVZBrttovOIxADSe0qALl+5H6msFU63fmQz/AZp7L4N8NY05wMVZubRjWOhu8ldI29AJqdCahONwPDbDY4/JWV7/wzaAGMQ2hKnKzc1s5kkJrHNm/rmE57iYIBphwCe1mzgN9dUZ6jcz9YrjQBAE1nmroaKipxW1aweBWz9oBAy9Fem0I1z7l/ftMfeAKrLoxopZYjtavcbwlypMeCq1vYvRQXw94p+RFYqmg3QZxOauuLRSkIPa0O+Jmsab04/8ASTpo5XXnAwD6qzglu0ZH6m0VuxtNq8w8aoGb95l3g7MFAOMFjS2c6egRAIJa1xu/pwgIODgQ5wimBiCN6L2NkWo8BPJAFzRLA4+faiy1htnLXXTkJ8VdsWANvOaT+ytOxPJq4Noe7zXSO2bzqftA+imWN2uM/pGQTne9cvnUnALp3bTiyS3Gjj6I3MWi+47tBzRDmy51i21cNMSm1gh13txVBJBnlMK8BLbxdu4q0tGibrC48ArKZNoLJ10Gkk/yrQuEzsCTQlF1q6LuMYUGSa45uFcJMTPBXrouOdIEVpSeeqphBvDQuRmSRMFElvAkVKrLRux7VSzJEYl9fJQ24Bwqe2qJa20nmgXyCRS9mhNgDmLrgfRD7va/WIPasHjvWKwQw3pxc+Xe6ADTj+SDXxdO70Rs7pNdn4SPJXqmMRhEeaMAREziKprgIlwj0XWIcXXmjCMihZvo4NIkbqKytGXg6LxbnTHDMKhpcvGMooVQnZFJyTpJDgAQd8ol7qgl0YcZXSGDstcR+3FWoNRdLjyRDGAMDid1aK1oLznUPFM2pa1kCc5n0Vpa7RJoJynGFtUbMDtonQAYJHYaAK1vBpvRe0DdO9Psp+8eGNnQJ0D7sZ8M06XAQwBWl73gGidZpyTxA2rMBCDWJbNQKwhgH2ZaTIoN/NRjtzA7KpvSmaucWhBxAbLjsY0wEro8S6XHirrAC5x23QoDReAr84V60AZpI8kRc7oQEXhoRJCIa8XdHXh4qIp/1BHo2t3gYK6L7Toq+zHxRIm87DVEuMk/keCAJhdY0zTCDiEL8CVdI2Q8ckwta5waZY7GmYKdEOMS3U8FcLpkOIDhtNOEJ143i6y2d9FdpUTO91VaWhresA8TiLjqhWLtWuO7aOaeRhg0aLpI6wgiNxTm2kXQ8uef0mqtCDF0YcSrKYJMujkrN1zGOTce1ZtdfDt7W4q0tL8AON3cBgjJcWQXOgYxEBPD4Lphx8exB7et0cQcNS5XyeHA6oluI6g8ES+0nZAkYknRNaQIBAGcJ5a0PaXB1c+JVlYtq4BvSEUxQgtbTHIAUnyCcz342pNa+a6RzgcgG5lBlm3i5AMZ94cIqQnF1dSqDtQvMvN1oVskA/C5T0BnVjrpVTaSNesOa6xI3hTRZFaLoRN5rYJ/IwUYM8QhQxMQPFXCWupQjFXiyIBU3ttl3Gsg5olpcMRhNOCD22jSzINKZatAaZncdeCvgX2k7bc5TGtNRhuVR0bx1tMMQnX7Odk7OZBxCuH3DAP6XZoMtD1nxKs25XKnhRWp+O6rQjQXv8sk2YkswOV7NOcRsN6snvO5NYwEDB7jiSMArpgw65hulXAY2IEZu3KwL3XLsucToTXtVkKbZLKJziQbNjsPJC6C4yeHJOhk3qDcrJ0xWbo0Ra58E8gAMSm2c7Re44eKvAOAgc49E82jhWZAr4ZK9NS2QIwaqzJTg2C4mtFee6yB3y9UtGn9pg9hVQHxlEFbLo/S7BUdTQqqoslgiTg0SrR11gE+76/kcuaCwAnL5qlnE01W0YF3Z4xULo5BmhrgrjWi9N4Sb3YjfYGl2IBAntQLQRqNe1AiW3sDkdyvOvwKSPd3oCye14iKnuQbeMjrA4tV8Y7kcnBzXA5GKkJsDFvgVEUrGcpoInpHMBG/rQmsEgXjJ+t2Cso6zg1hpprwmU6d5EY3j9VQZE2rnwTpr3KSIYx2zvumFawbznggaADBWYMOFmYHHMldGzC/Xmti7fujtKF2prdn9QxX2UB8GADOcCqvNfQYGuO9G6ILSCZ3jBFgYTtBoynXlqjfkudkfRXjeh2gEHTVWhujjJkxlKo9lnyV60tQW69GEbNts20Pwlgae1Qyz5OJ7porwlj/AHmlbu0ezD2YJzrheXc431VT+Sx81da8bt6L5mSa8NVdbLRiM4+SxrrguqARjOXYq2pI7leqIxII80WC2Dwd4X3Vs1zc2lEhrWH/AMO0bhwcPJEPG1FS1ag9qGzDr046KNJHem6Co4zKs3M2nHHS8BdQuHZkMbvvNFeSc+vRMAbZ1iszO9NtHUYXl0EV5plgxsFz6RvogLxpiefmnWYdF0bRmrnnJXRwlFzJAxBzg5qreA4BF1o0B0uOgBhCyIgXhLoxGYTmdZol4GhjzJTGEwTMWbKuk5kp/RiXQ260GMdSnWj3tdtftA3BXhZwTMXsAFIaXnLeod1vh9U9xYSedeavgDHa/TohZ284C6/AhyuP2hkc+Slrp9pUkwFZNnZjKqp+SlAAwujMRkQou7zwTAXbJwcnsGOKxVSXH2Ag1G5bc3SIKFpZO2xvx4pwreQd8cbWhAW+J5p3d4q8BANTroO5NuGBeut5tiVdFWNa5jHD4hiVZzDjcdjm5xkfNPMzRt13ExRbdn798UxjPhGC6Jo6pgu/UcShswJwQFMJMbsFAJJNJ11Vn8IcDxQd0sQa6p3Qtl9pv7ycgiLMX7ciHOyb2oPNTdmAKnf6IS0m0Mk3jeu5miwdN28GupGQLkXOaS7qtg/UFdXkMtwHmsQBhVCv3fwgd58k7XL1KuWnbmFX2QCJXWruwTWQROYJPinkYCg4D8lCgCFezjIpt9myechNEz0eGdE4Fmy/GN2Y3oEQQalOZNLNoHMovzPtbZWLC57sAnCHCsPaaYKTFcOSoNkmab08/EGxxzVyRJj/AHBPJpfN2vZ5JjXP+7gkBMBowmgwIv17k546rKBGzdSk3tBghaBpFnUnWGoWgMMJndvKmIEdylv0NVQVLZ5KGjajH0V4im/JVdAJ4krpGPi9kWtrzlBp2DGLQ4/JOYyycN96SexXujkuI5xgi54NcGZ802GtE9w9UxrroBHB3ILMd5QlzsNkYdinx9kRihAeSpPYrS2xvG6wZbysAOH5PFQ1tTvRE8kDIvIgCCDh5hYXXNNQvtT6T0wE8imftTHXjLsBkoGisrcCbuI3FG2sqWoz+Ib0C05ymOH8bkIFA5XQMwZTWvBiAOcwi4gbP2dzrughWYbpeM4xNAoqAX9wEpl0bLf4lEvlojLGuHchDTAwHAYBHUnFGawnESJC6o1Mmq2i0iJumcl7vhCzdGqEBoJyJpzX3Nnen3ZEHmV97a2P7WUji5ON7rHrN05SVXGIkinqi4GATUuoeSpM81rv+ZTnOiIiibA+aJeJPw6IA0zgfJBoEaac0GM/t2YhvmfyouuHgq4qriHAzgg8HZNHCc1UYr7fZ0mlo2d2Ka5uTapoPuiFXJo9m/2PGQciIyQg1JqNwTGuB2nt7nLpHdV2ywfEMI7ZUGMpTDFR3zRXXNN6Aacwq1Ac5xPH1UzjhuCMATGCjCm1XHgqB134sUAO10lXiWuE4k48lVga3mFcEcf5UuF7vToOuI7gqgA4EOddnwTeja2BS6CAPNAuEQ3KJHFS11CM6F3mibxu51w7kW2TXP7QO1byawaIOL+GaaJFoAJOzXsQcb3d4I2bXG8caYD8rEoShkE0gnZNUHOPR7I/bPmgaB2o6rvmm/aGZUMb06wFpqbI/E3Tki4BAjRSau8FWK+x8n3kVyKtWtmBg7gnQAXBouTvjZCDSdoAF28mgVs4YhsNnC8Fdm84MDZ1JoU4Ay4ujmKdygA80fBNL4IlAAQNP5U3nn9vmnO6I46yIQcegEYFsq64NcNcPJSL5KkOMZyr1y80YnEj/pOCPRv6Led+hlC8+8YmTj5LqkCqmJ4n1V11neEYkx3KktLawCHTyRN984YRvxTKEXDSsQi1sFx3KXuJk/jYqhHauqVX+keiwUfJG9QHFpw7E20sQbuL7PI8AU4TQiHA0V6zvBrXS1wxYUbP7W3HC0AofRB7S1zToiGgJxvcj7PqijNaGO7+UA29crQZpoAhweyDzkprzndjSU+aguk8skxjRteCbSqrkopPgpmSuq7nmj90zcMYQ6RjCJyEUReLQ3c5iW8dy2XNtBkQarHLCYPcpk9k/wAq8yzxxpCA6PAe9tHulGTJjA2ZB5Gil4aDliD2oukcW496M3ROsHzRigu4YTwTSQ7KQTQcEQwzxqp2ROnmgdCiRhP49F1iqhp4hVsxyJCwcOfthXpogQ6owOiM3nDHGeKYRaEsJ0FNxRDmxoaKbsHcBVBzdkkIx1RqJ8V95c1hrQI7E455J1a5BTid2CqcQZ8ExzX0uwZx/lF/Rmd57E4T1cPJBwoC4bITn6+yAAXnqgokmZWB9htLUuLxaQQDEBDoTs8fVXmGqADjcmbhwTS3HQq71TvFCoc+zad9VeZaAu+tExznTXWfBRcAp1k6r3zyCuzG4VCIx3ol1m0nXEdyrA3fk4AJOgW3dZ+4wq28/taT4wqdKewLqkHjKwUyD4qKrCZyKksGGIdVCSXaVrPJNYDdzLYuh43SpsulJioBkU/dCrEzhEH/AHKrmyMs0WWbaEwSU1uAIvcdEyBG8q7eAjGEALuU7UGiGB4b1LXRpTMbltQZxjCcJQgZiB5IwinGVKukxvCPFONm4i9iNU0vqSqJpjNC0EhXJrr/ACiCLw492oTbsNmuKmztIPvQMUW3Kj9NCuoOTiO9OvBvIIOvmOCkWgfzV7ZnvUT+QoMMTgBxX/EPY31KgOut0bsju9tVIWBlZLqrqGmlU6GTAqQixzHRdwB705kP3G9TuTRSzuijXYFbYiKho2ge1OBw40RN6gpGXMrbsuM4clFBEgHdMqjcZQxH1hVXi8VplC8lM9VXpV4ySQKBGh3phmpxEYKcxkr0Qjo6oQaOaEZLqpn/AAxL3bmNz5lA3do1UZZBXm2hJGs+JUPrXMChU3G7x9FAEEmaGnlKx30E9q2v/bCmMcqQpxGUKCyZyRpH48u5DVAZDADD+n1WCy9glSMNVekt4Qg8OgOwOAQbaYj36KhujMwPNXw0mMSPHCiDRZC6cAH48SnvtHOgCk6lXWyYz4KpNOakmQhShiPaRNfHmrodiJonDGqvEbWUZZJxIG6EBaTc3KhmlCoLTE0KusbAzVa70LJrS8kwBP1RdGCHVm1fkY90bgrsOjd8lQt7FUSeKvtcQj2LryTjEgq63twKq0OOoNVWzkHVdSngi1tRrEqv429Vcv7n+0r+4O9f3LPt9mCqFGKw9sOogce8ICMNCmikHAkQQdxTtpzvrinEO5EzCGxAxcUQRAFaBEg7OCAiQAsfNVdhvVDnyQrkgZPknNmVUtbvxTRBoZ3qiwrFDoo9wcx8lt/Zic9lw81T7NaA74W05lmDk0yUQxpax/Wd7xV0CgGiP3gOevgqzGpVTeGmCi7snLFFzWup+mPBNqI0QBMSaCKol0mcaeihs8T8lxz0R/EhoJO6q27tn+9wCrblx/QzzMKlnau/c4DwC2fstl/kXO81T7N9l/8AT9V/Y+zf+i1Usvsw/wDJaq2P2Y8bFqr9k+yf+l6FCfsdkD+kub4FUsLp/wCYT4rFYKoPZ6Kju9Q7tQajiJ3aIO2Tq5CuJxu4rYMx+lYZVHmm4YoQ7BO2aKMUIjfAyTYM0mlVxVRS92q8DQnargdITZb1Wm6mw29rCkga3TSeCF43f0nfkgQBJ0NVBB5lS0RPNBofXQGvYVdY17j+lTaMtGTw+SNwjATjRNbsDTMoue4cqL+5QDeqAqajfiquB3HyVAcJ+ijuXNQ7L8LZs53ur3KL5A0FB3fg7IPJCThkQspWPcqz2LNVaFSn+UIw0uOhEjtCADGR8DU15sQJxTenI2qtExRNuBoAwhOgbxinNdqg0NRANdEYOM5ppPxYKtMUOKcXR6KlneEVjxom9bGv1khUn4gD3hOdZDjvR6SxFBiaB0+aYelBZ7uzervRAtRqBdPdorjbzp2jk4cdyhzQXx1utRYmJoLvyQvX2UwmZKJkFudIjxUNAka0U7I3RPiqsdxikIu13raE1xlG56KHYbqIlzsES1vskhbmip/G+7snu4NJW2GWY1e9oX3n22yH7Q5/kv8AvTncLL1Koz7faDdZthS37L9sj9d1vkv+7D/K2AX9r7IP3WpPmqfZvsLuDS7zX/dPso4WfzVfs9lyBHmv7BjcPNVvdiNbPkfNNq3GUC11nOZwjkEyz6IuGBcBTiqt8SjatFCodmuSo8oOm9CqIA70BQmMFsidwGCqJ1yX9sFww+igWNwyMKRB5ogUHC9C6z4fkGo9LZ9XF0EiNdyDmOviNReHajsHg6PNCGifeOXgFAe4kZQhQ3coUwQCjAJ7/NNa1t0TUEAobI8FDaaxKY55jTer7HTqFBUCjQpRI6oxlXMlgsPwbwEN+J1G9q2nutDozZHaUBYWFm05Q2+//dK/7R9o6MHK0tI/2hf3LW0P6G3O9yAsfsVlJ+ObUqHW9nYD4WtbPY0KXW/2m042haOwKoZzBJ7TKp9di38ZWzYPPJf2Y4uaPNRbW/2Zm6/J7AFJtAR9aqJjSkKQ0Timw5tNaoQdr4p/hXbS8RGMeq8k4EYhXd6ZXNUqsJGkIHo7rVekXjpl7LxhoFTojcicaoNh9MiB5otdZCDiRTwTYMDGSPNF14jOQJTptTfwmaq80uOghR0hcJ7FHSSNJQltFQOB/UgLkTmEai9HDwV82rDGV6oUOu8zBVXODRpRQHuc3QrDvQq47oU2huhbOCgYK8cldLU66yUSWwFvVG/0Q0KgFo7U9UeqzeR2D0W242rvhbRvN3oi2ziybpZ07Tj7JtyW6WY63PRXbMCzacm4nicSrxs7jfifsDvX3n2m8dLJs97oCFyyc/8Afax3NUMsLMftbPeZQDvtBbuZ6iAou3t9o6/3YK4HE/pbQdjUA2wIH6oHivvrWzadGguPkvu706mPKUHF0D9Ruj1QDXF/cB24oXgQO5XgCDv9mKZbDA4nwTdyZZxUlVbJ1hCAoCJrHhxTrC1aYwN4Uad6LQes3imzhHDsQIG0MJzCF1obONadhRwadwxRewwTkKKjg6d/ooLpj3XV8VjcI0X3loHDcfBUDuxGNqThmoDgJGdVMGNRUdqgtTZMaVVXAwcF1TM4yVnuUHaKFOKF2Kdi2zyCkmFdajXkEZElDFTcPsvOMN7zuCuNEN+EZ8dV97V3/DH/AMirtAwYMbRvsDWiXHAIXXND87V3VbuZqd69+2OZOw31UWd2yH/02x34q85xJ1JlBz4s2fE+nYMSthhtT8TqDk0eao51MGgQBywU2tq1gVLO0tj3eXgoZZsYNPqAoNq+NBT/ANsL7+Gk+4Np/oOaAsw2z34ntQuk79UW2TaDGBPa5XjPE+SFx1dfqVQ3tyF70hFjuxFogAZnPgrz62pxJy3BA9vswNcc00POy7qlOeBJPaEDSmWvMIBj4bkHVjcjeF6DmaEK66yu1kUEdqGVImFfrGsqniiHTB1EjmEBdut4yOS6zkMAfFUMboUtjeqtdyUNviNy2CDz8QtuBRdWdMFE+zaPJC9AGiizLVtOkq6wGdVN6pyUlbWOUKmCi6gP4A9FFnjm/wD/AB9tMJiUbOwq80fanwarziSdT7A60Is278TwC+5ZB+N9Xcsgr0F0++4+ZVSba0GLW7LBzzUB1xujdldY9ipaHgj3nABRZTOdoceWik05VKFC1pwjrOjy34K6Id+kf25/+a2idzcP4U0G/IBRiFVwhQDKcZrXmqRIGJQJNCoI9CseSrVG7HJfdWjmAZqj79BQ1mPNXXsLQsAQdVLBzlVEHsRunkRiqiFu3YpzQ5+sESFTLRdYExwWVEHse5jj2HiFJLWO+LFh46IglzTp6IXpNNCVcgAFfdGeSqZ5KpQr2q8a7isGSchksVRpxUuMuKwkaoS1QG0UyrjMPePxfL2hz8D1W5n5Kh2zSlAxujd59l5xDGfEc+AzX3TYPxuq7losyTiZ7yVDR0hFS53Ub6qAXHVxxPoNyjyQw5YKhW0acpKjBuQ9Vsq8+IxrhGp3eK6OzvXTTe/ju3INaZ1dlyQBxPcEG4Zn2Ae75I41yCAGgQA+IXjqckJNCfJXUPNBt4URh+M1V1zTImnp6IBwcwjOEHG4ZwOqPRPAPwuEj5Lo3S2cjVp4LdzQkTwQguwUi64HMY9y/tmIyqrwjzVwidJVDSeqaqQwkbjI7CpEhAPc0t44cNEfeHepdEaEeqo00Wy8g6Fq2iChsEjcouxG9Ch3rYs5KIgzoutO5TdI8FqUP6LzhTTUok4q60SVlaP/ANo9VecSTqsYAxOiFnZths4Zk710bTQGp+I+mntq9UKo5bRMrpHjYFAM3HRXP+r0UXdp42tzTlzUnBok8lWpKJOqqsFqfFVE6+i4pjdPNEn3yAns/Vs8QmydxKeTSCECfeFOIVYvBtRqCj0WJ9w4OG7erpkx2t9QrpIcMpwWyTHwn1VRBzac0Ohq7/huME/tOaLXg2b8NoeKoRJwBwPA67kWkdHaz7wov7ferrpa7Ka96AdHGFLYB0XWI4hfdhqBILOPVlRaEApwDQ3fjKilTii1pK2nKhNELz9kb1dsx2Yq85hCImqhrQN6wBVWj27hgrzjdbrrwV1gutz1PH2QFdbgO86ouzdRvmfbgFIpwWS+Skm6wYn03o2jqNYIY3RbWGLuAqU5xxKfvIHmnQvNbJqte/8Ako78c1HvOHYhThyTeCBigFFOlU12hPgg0nZtGEEcahGyJgxeG4hYw9myd4yTYzq1B3vxj5FXmE3CdoO912/TioIMZgoyrjbVt7R1J5o2H26xNoG4HC1ZwJxHFG1+y2vS2ThiBXg9qAt2XrtAcxwJ8Cr2LdQgLrTHJUHyVR/lT5KuGeK/SaYq7MjUqX7Td2IU9Zhwdkjor0U3+0EwoMDfChlo96qVHeVM4e3eVtVPw+qk+2czQINGaphgOH9GJWqnAIMHHgg0ZY8U/hHapzVTmoHsvvz6rVOZVPrcFwI7kzX0RdFcUa5+ymACaMwxvbCZbDGzLXH9rqo7nR6dyIyB8Uc/TerzXUwk1H7XbkQ5uyOsM2f/AK71PWYcHjLipTWWzb4aKfE3gfJTZnsp/BQJoTnkeKOIcO8ea2RX4c+WqIvI8KgraPRuyrA5ohzBXTxopvQnOIEbkfeY47VEZdByORC2SDxEqpEaBUahUFQ4IMg/4ow2JzKmexQZVVuU5/0xpRO1Ijl/TBICqZQL3UbWPJEnEmSq+2iqVepPujzKqZhY0QCpgFwMp37Sn1pT2AYE1O5qLtTPBMY40dZtY4cQgw4uY2dzhTyVrep92ZHDNTJB3Zb1IaIcNoe67+U1zbwb7rveYfhOoRaWjCrcuW7cpZgt62KHu/hbIribPzapy0nw0V5pJA0xCAcQHnM58ViWEZ6LFpnT0VIn6wVA88ahHZMjJQRsxgrvWrszl/KJbKghG6Vi88Aq2cKGMIdqVtPLldy3KgBOpKxC4/0j+r1WRVQsTzXy9tQqQOK908FJWClRKgaI1qQnb8E5v6KchKnE9yNSScU1pzOKdaauJHkhoWk78SVaE0vNmf3IEZIgDDJSBNILULhwNNRuWFcwPFG4d8KMfrJX7O0ulp5QqOuWw30PH1VXOa8O2gRB5hbN2fhxHFqDXNwGOP0E9pBYQsjvzW2SRronTJUDkvJTJE+PskKszuK1CGPNQxwrmscdVsdqkx/UP6uqqNKo1VHsw9tSr0cFtAj2SMFVURjROnJMJ+JFvHuQ1R1dQJp1bRWTzQXSCdEMMPCqaZF1zccuCFq2hpIxTXMw8iqCWuGIx/lMOLZG0MdxV8GHNG0AP9w8wrp2LfrNczC04b9Qrhul3gfmnWlmLrxlSDuTRaENnZY8+474XbtFF67aNyR6Tr/GM/3equubhQFx18kR0d14NWyiRO+VMtI3ouERxRLZT2Ft6YPYgC1wWBC68Kruaq5yJOO4rrECV1mngqNH4eP9GSx7vZKgExuVGqvsAapywUqmqIxESrgw800xmrQ55c020Bu1qjGQ+SawGrSnsyB7lZcHXgd6AaYxjREEkGmpXW5hbRg/ECASuhe4Fr6B2Ba7KVdeHMcw6rpmC5tbYHuO14FdMK2zRt3aXm/EN+oV5jidZxRa5tLShI1yKbZ2huubSzJNR+k7kbxcw3uSuFzY91wxHI5IX6ubmMY+sFN43cioo8TwRs337Nw1zRDhTepbdphGKZedPFfeWcjcqWcQiSiARO9Fxe3khs0VGlReA/DoxZLIezaf6qk8T7Pi8FVXnBUUBXniNG+q8FTtROSJj+CpAzUYjvUDEuMKTUZLPTyReZptDSlfFO2YICZtVDf5CtC6gkYKGlpB3wUZZTfQjmEejMtxhZTkf4RdJDhdJjRwofJQ6CI7WoFjyIN5rty6ZlB7zRkd25S2OxfeWVS0GuElFpaRaAQCPeAy4rCfEcVXDJ0oubFcVHRzOOhG4otZaODQaNdkUCQ1XI2t6r24otJgbkTQkDmodKqJCqFdYHUV3bCoDz/CqVQj2VVKLX2Vw0VBdb3lUBXgoCkCuq8SUAKnwQAFAjxW6nig3GleJQu/UJ4yDvFPBdLmmVNmRA75THkbAAJhOtKR4zRGplEMcbzf9yginu7k0tHFQBBar0bXirwrENI3REIsLpzBONVcdrQ7/mrwEj3vmg9mDhsu14prXNgxUBB4rhVqbab6jCD81tZnJEEmR3hOYLWHRpMro3hrirxbIIwXVu7igabkDcCoyAqCVtWbq4QFIdA70WtJgZyqucsO0/hzX2ZLqysuSwVFvUDDNQ32AQqeyp2AgJVqcxCD4ikoCM5K+0PdQ7McysdZ5ohpqRI4ynMbRuACuSfmU29EQJ7EaYRn3hcclWSMjgVecJ81oJrkjTGplZ3mYcCqmoxB81ecbu9OsrzSx1ROu5XhOyatOLVe2XaqCHbxnG5AGC5uDoxG8IS8sIwcELWzulw5direEZFbDiaVEqrSoDv8c0WyCB8Qqo2m8FS0dO9NAtIj9MIXXTrKq6/zVzoxOuKkA/iZvKrDfFdW9xUBolbu5RiTkpfitnqqB7JRZOGPFEDFBoC0jFOa3lvTWzUY9uC/ee5PFZB80ZxxIWdDRXsdVNZCbukclKBrTJNivkjjGKMHFQ4QQoxs3SCNJUPrNG2o8+CdYPdN4UmoPBEjZnLQ6EJtrO0Nlzh3ErJpyOS2mmWhYbTBE6gogwNDgjYvi7abM6SjZ2slzSQqAzmhdOCJIaY0oQgC694qWmOMIPcexS1/ag03sVtBwOoaqEkSh95HH8GiqpLqKGtKwA4ldeOSkunipe88M0BZt5q/a0GipQDNbPsAb1lI7VJyTn7gjo4oOacCtTePagThBqpFTgfBB2d2eaDtCFaNilf5UdqmMCpFMx6JrhSeyVAoVDhQ4IA8pV4GHDVRaicr04fNWjrMwDDtxDs48UHDZcOxOMdba5nEKtJoQURd4q7QxhKxAnrDKFaS2+0YjLit+Tc1Y2jgSSC1xGTm58wq7XcUCHmzOV5NI2Scd/ArZc2NHY8kZeyN+KjpJ3IfdiFIFexXSIaj1RVdbu/B0WMrUqeqqmVsjmsearQIXW7epW0S49yk0blvULeoxc5C6MVdGHmgCeJ1KqKNbgiIqgYwr2oNAnP5ITU3T4JskT1VTKUDnCAV7TwQpNm41H1mhm0iiLCUWPmHVn4SFU1BqNCMwrzDeYcCMtxVdoRBaayNEx9nBbEXcxFEDll6FCDUFVwmu5TndyzCvF0ZXo8UNkitQmvbWZZjgW5cwr1QQnsBG1Vu5yLhF4YhXXGW71B2hlkotbC8Jo5fdsIHGULzVeBKF66eUKrCpNYyNIU/g4KseyVipguPcqKQaj3shwWyJOqwvHJvqVetDJyAwCujHvV1ueKBZrAKukzFVJ7Fy8U4NyFToiAIJMrcHI57HiscTRADrHCOSrm0kHerhMS0p8YtRAFZKkYuExvwXRvqx2E5FXXdU9V3DVWrYwIdZ+fYuls5FdoDJEA0c36lB3vaK83mFTPnKdAqMkMv1equlsg1BGA4K9SH0vYtPFOZcLY08RqrWcWva/8A+Kbmr8xPcpFHZcCq13IwBuBKuF0BEh8cCpvdyrc4SqtZ2o0cBxlAloPeqExub+BQKrlJKpgsL3ghSnYFtVA7FgAFLyQ3IKjYblvW9QOZCi7BdkMTxV3NxqfIbkNqAO5NAzqdwCu417U60kDRfpnDVHL0V74nIgVCutxJEKzbNQ6R2Jhw+p81ZmIoR/0lbQ+7fZXwd2YXWq0Q6N2Dgr1n7p2hq166S7X3hv1XRuMiaOzaYohJi0btA5OA81eaKHrDT5LUKi0KgOgnJEOxqJ8inXoDhjVGKtcajirlXMfiM5QuEsIx3K3lvWsHG7kSK0WIBGRThNwjFuRTYwQNZW2wAnv4KWzwmoTSYHLFRgdynHgaogvuqhD94XWUEzz/AAsCUNmFgshvKgTav1PVbyRcdt2vujmvuxT4vd5aqGn97yaI9Gdn3noQCB3lEnHNOcRWKSgwa7Tt5TtAK8dE1oq9xjtxXR2eOqYPeJhOjMn0TXk4MEKzOAGyUHxEW4bG40RYQC42JI4jLxTAJ2WlxG4Itb7r5B4hWT7PqXyQ3S9i1QAdk7J3ack2m1ZtLTvafRBw1qjZkVlHTwKgx6rYPJYQjFfEfJfeRdOfogCJ0nMcc1fa3/HPvTrjy1w9zXkmnCHFbQmMJzVqB1eifTLBRcBMVg+CzkdV3kr2Yd4qvMFFrYLPrBbVCFGAW1DgoGycioLb3NbLS1VPYqeH4NTCDbNp4radJUMUulx4qSAGdgVT92FdbN3PeN6ZefTQZ/tCvZN7B6lAubX3W5jii8j9u4aq6DQ98JsjanDMuKDZpMnii97toskN44BNv9e+C7kJ8VSS4Aimp0RYD1dn1Vm3C6xCy02jzhMfq1pP7hQ+CdaNkSbw8U5wFNOKYSKwA7lRFs4KIEFB2G9bKFa5FAOFc0Gmdw9FiNxwK2Ad7Srwlp4oBNa5pug4afJXWl0nqk15Smm0Yb0kA/zkiZvCktOXBOdNPBWhJgmzdXKtEbrphbXWWJk7tFTq6qjQ6NCpgxqtgmdFv4LZDv8ALBRaCTwU2dl20Xkv7bv681gVQALFV7FHcqjgFL3clJ2GZBdU7mnzRMF9ocTor52nZHIcB5qA01/3KXGSaBuSAA2jigcXYJtwm6Gz2pj7SaEHhCbOIaRzdUoHOaeqCaDunxTuIpuhERhJTafQRnA49ig+6e5cKgolopMq8MDiN6latjDdu4INtHdI04OzjIq7UtmmoO4rar+oY81sk9tFDqKpBBWzijg4b6QiReGRHyQdfu0rmOYQdd2c42grSaiAgbNwbK2lW9IwQNWzh6KWgb1S7vQB2SDiFevy4KQY5LAXhmqtUwF1jy/Cz5Lf8IR2bsdixJ3qVMf5HyVG8yoi8e7mpNdAFstE65BE95RujdKjLMfWqdNXHIDMotaMh2ICsJz9RimjOJO6U0HEhXjgbW6UI3hEYZhN0rXROyyVwmrRM7h/Kg8uJ8in6HxUt5tOR3IlhiD1TkV0T9l4q35K6/tV4oXSK4CaFYYotoRuw56IThlNHN55qHNrqNENoThXFbZlt6nHmrrWBwPu4ditWuGMckdhj2fqCi7THgg6+oeJBUXSCESpIWwY1RvOlbskS6hCDQ13FVns/ChpxVXR4qKhveVEQN3nqqz7cSjOGmqq3gMkXG7JFB9ZIXBh9SVLnSZx0Q6MTjO9F9oaxjosKATG5MDs4J9E50+6aprjhcJPBOtPeNqDwNUSfdM96sjOOeshGm03Ea5FBzaOuweIqES+Tu3Zotq+yrdO45K99FNpuWyUKVCnGMQgfd1y5qDgTpIKoZ0nFY7Q8F1wGnKcCrto29dOy4Gv8oiGvBGaLrzo7l19oHq/yhsgGMlXTREEI3W44hY0V8jbiu/esIKqS3wV1zCN4UsivYg3CvJE0I1lXb3eqPI5/hzEDXMoTIWY7l1isCq0XW7V1wN6u2TrxJxOCNmwVzd6K9iNdSruA8ZTW3cCtrqsM+SIbjUu4gJt52DTJQbPujuKLfiIHYnCNm+Smt1JvJjYwTbwxAqnAIubjGB1VOqcRoVQ0RB2Tu8Qsrwx3qmyVIrrGSia5iMUcC3MK8wzd63zWOU7+SuyNoY5FQXwyajRXbQVBMOGfFDZmW9Vx8CiOjc1wFbxrTxUmxivWbVY1RloJOEjFEtmBkicJQBMFQ8lEONNU2Qa5K40y06hXXnePkrueRyKjowd4RvMM/t/BwW1dHNAtaHnWPVQZHOF1x2Erq88Fj7YaHEqXWt3cFBOJ0qpDdnKUHHVEwa55o9HIJJxxKuvIBMk8Cr13EjsU/qKYSKNaXdyu6sJ9U2MiPROHNXY/wD5OaIPWB7VebU+Klua0KDsvBXm1CBmRlqib9D3LadhmaEI3yWnCfNSMRmMwqC69uWHYgbwdXB2KwvajP5qdrChA7irhzqB8lebDnaihCAdEZqlpOcEYIBuyNcR8lV1Rig1xn4SrpxBoquBUlstVMPBZSg4UhS4xwqFszOoVAzmfw8+dVRSZVSoaq2kBVN7eVAausAgHAukoAacIWXoops4oOme5X9ZaOeKsxmU+PetIHKic46kBN/bQbiE4g9X0THtNWyW+iYdQYTbQVpWO0FXhgcVz7Vfyz3Kjrrvqm8FYXXNEGMCFdNQct6lm1d063AqG1IPVIhwW89vYtjHJEmzG8gweYVXAOyJp2qX3rNwOUqGv2sL2M8ZVSKVQIrwUAPa/UIG+x00vBA36DrBXgaBOBwKG0oKuiYOIIwRa5oQggr+4AVVo4qbOZVbNvL8LBVDO1YN7SVnyHzXUJ4hD7s3tJ9aKrq6AgrBUMqa+akTxTWMjOc6okzAxKfJrFVZNmrj3SrQTQOj5prRF8NIGp3KyMiL9N97BOblekc6KQYdDhO9mCtXTMhxjcKea+zTjgeQTC2ox7E6DLawD2osblSu4r4XD4t/kVWYOedECDnT0QNTEGmMFAgCHdV4w56cEXe972qb0kkj3s0C07QzIoUDFRyK+8Y4b8fFC8Q9urcuSG3T3YwI3gqOjD57fmi0MdHw6dqlgujMAz4IE10rQoNghqkMkZqRn7u9EmyHFbMgjIo3sVzRfIDhkqBStkS04hbTJBw3LZe6N/4uJVZ9k5DFQxgY3hJ71m49q28dERSVOI8kbmHDNPGohX/fyOk6KnFAb8VJdtMEg/tV4nqivigTXXjMq0FdozwVlUmHgjgRVAuqz6hNcDsmhzgjAo2jTBo4Z4ppaMuqixpP6eIVBe13hXS28Mh7wlOAqw4j6zURNYWzQ/DlyRiQ7RyLdPdeIWy64ZwNR2oOYf3AUhG/U6hN2OEoPZ1gMyHJzujbOceiLbRSC80rlC6zgYxI9FeDhIyxRDrwcexVgo3XFukpwIhyJKBBvBfQUskGFDxddwWw/Z4/iYhVI7Vi1SbRsaxTtQFlZzHvO8goHqoLydy3+Ckuhu9NaIMDDBUAHMdy7ZJyhUBhQcJVWncgeqMl0dbtJPBG6IRBrKdU0gjcrh0xTmOMU2Srr+rUHdKAihz0KrycFGBKmJMdqkngfVFwiDS0act6i1nd/Kh5IGpFPki04wLpMOCrZXp3wF92COKm0vD9QqF0ZLBpBkFQ5k6KAbjsq4r7xjZwa8V7wsjqJry1Qcx0t/TinNDL0ZhEENcBuV7TFpVMUSW5I71GWKEGmq28s1Jw1BXUngfxqglVaBGvzUvtKaCSrtm08/kqCupwCoUS6XKSYAyCns1KcNWlvaplScch6raMcU440xV4yAESQnU1TjEiKhOjHMa5haaFXLQRURKcHDqmDu4q4frggJ2hgcJ9CodiMHfWah2stIz4JomSzLOEW0cIoDoth0NwunJBpFMYy5KhKpaxATgbVs44kIvA2o1G0pbN00LScF94A6dBJ7ldbIms+oKdQKSB2+icYpr6pxlpcrzW0OSMqkIwJTNqmSLSpvc1BqDos/xut3+zAqpuhBovOV9ygUH1VbvYxxioklYVvdyJvVBK1g+KbFJpxKFkOq1PbgQ6D4JsGhi+EZiogjUTiE2/UQAeCe120AJDhocCmF1awYRh00gEZjegDMTAUnKhWk4zgd/FOECdMj80LxqMDgpZEg4TCvMPFqBaWnUFUkcCvdJ16pV03A4HB5ryRh17UAIsqD8KmAHDAqrdtu9Ay6d62rzRNTkmgPggTMyDwRc1rQDmK1XWMrq11XVlG6YMoGFQ/JQ4A7x6I7ccV/cI7D+Nj7M1UXeOPYtrZb/ud6BYVyEUby1VOaxQBqSQm/UIRkFN6GurxzomuPvYIRiP/caK0foQFbE1NO0mqLtIUZYt4GqjOTVWXAtPBAZjvRnm1PA62uRhRaAkOEHlmELOWvmtm44OHwlFt0kgYHFdU3TjPkpvQ081NptMOa2HFxjEYx5ogk4oNLrp31BQvOYBioaWOGWIKA62lFRrQexXmyIobtUWWglumHMK6WmFUbPgjMHeKq8yoVQCPBYlNfQwhcpqtChLsc0YF45hYOH4/othsb81I5n5rZcJ+IequsJxrqSptXf4q60KL20Si3KMVXkFZyOq7sAW8ZbtVZMze4HyU6+qc01g4o70CRgI7KqcRe7oQaDTpO7BSOqR4UVk+zN3pG/7tFJUgbLqgjEHcix0DwJ1XwvGXonB2yTjSh+tQg5hB1b7rh6qA2WOAgfyiTRuJE+BV8W46TCcA7c5HZcBGGIRcWg6DHvWzQaSheJB4IAgOV5jXD9MobZEjPEeqJZptDzTjZuEk9XBbXNSP5UxCw5LZzV4hAgVUlpoaqRgVEYfj+ZVBeO/BVM7svZsiuvoiTrCoKuwGvyQBMuPWO5O+BsHsQk1ArxQc7MTHhyTnuNcVZOOLWgg8kxu4c1U7UEnyTXEUCuNHWMuPAJugIHkrvFXHjERzhOsj7vVT7wF6cd/zWGwTUaFHUCo3aoC/XFh8l0VqMMDmrjjG9FpJ0hHaxGarQoLbZX4hjz1QF1rgd8IR0tMswiLRroyQMyzXGFUm4eccFS0nPCnyRcZEmhRcDIzCotl3ELesVuUHHJQTHFXZiqO2W7vyOgXgidEKUGCLzUuoPrRXBifqVDcB3oEjA9rj6IwaAy53BFpxI2lZ6dGT2K+RkAFKLcsFUZKygVJ8CmOBqSg8fF2FNtfdvN7FaMrcccRkMQRwQvjCjiMHMKaBF8VY4HrD1UgCcwES5l7hQoFpvgYfEFPWA7txV14IGRKjrR2hDADUUW0L3apDIPH1QcTQZzUc1t8nNy4pweYyOhXQueC3EEZKphw7wgHDHAqH0QDGggqdO72DchIUAgjJPaMRkVE1GI0VHfkRAvHfgnhhvOxtLX3QNAoVewIXovkdT4W71enatO27u4qBz3bk4ggaHQappAoTNdAaSmtnMueVOliB2lNYTtE/NNbqe5VxqVcyaXTwGCgUlxjkE2Pds4/6qq1OTX3kbP4hRAnRaxkvu95Zyxb6Jj2k3hS8gSC0+8d6DwPNpQNQc81kW6ZK9JEdyukNO9Q0Xhk8V7QodZljt/VKoLt7Q07lUnipneQhAa4aHyV5oxyNUBdjULCiNSVN6d6m6pAVBVYSM0w1BGBR6RokijhioiRr+QrVBtAM8ghZWOzZjtcdT5KG8yukgOd7vFYzJl28o2lpUgUHw8UGDAVMJgB2bojfvQgTHVHmre0+EYqXjZZBO85BOtXe4yvEhM3NjnCvTssAnipyIrxzQ3IanHgnj4mfNWR95sDtqncfZGFZ5jBydIxxQdrQrqniCrzQHA1j0QdcFRWMeYX3ZnxRyOmHYv7juJHiofZtccy3FdZ0HBbNoDTt7VAddIwGSjZBOI81LJDxi12fBVx7CgSpY+VXFUW1TeiDyIUOWy6805aLrciodAIpX8jGS0GgQbg3RQMu5fE/wAFtOpjAQaBjlmZVTh1uKMCAUyybgLpO84+aDJ6tXcc0LL3rR7XOGgGARA62HAINidePyQPZ6oOdMDFWoH7R4qc048O6ic04FxTmHrQY5IHetxxQ4doUXVsEtIxkZotc0csvRYnXVGAXM10W1LtJGSDhBPehMGO1UdDsGh3qgtpha5QZ3SUXWkPUlojKFgQCtoCciMVQRTtQBxWKDHUmoRLXfMI56graAkUr+Tgcyrre1Fa5lG1dierx1UuMAYqtKTGgQjEmVa2pqLNuHxOOCdbPk2jhsjec0SY3re7wV4jhwTBlNSnQesaBEA1EDsqUDlPin7yYTHa4p2+ab0NniEWh1W1apNIPYpaQ5uRzC+8ZcyJjxUMgjt8VF51nacx4odI6RkYqpvUmhj6hbXWxDhgVDmbWWhV6ORQ2QWZ0wUjaGhVBd1ogWOnLRSH0+EpwvFs5EQommSBubWoUO2T4Lo3/wCJ0K2jOii0xyOqO1H5XeuKvkYUaEGmt0yd7kSavcZWEkprNXyU7dRbVScAtrNfCwIO7PVDQHwQKKEVMwtwcpyDjPBCMjBUt4qesD3jRZwcwqvr7jxgU5rnwdI7ldc683KaqCDd+HJbNfFAgmMjiOaF6QMDWUYtZ0rVSbVrxqBFN62BMoB2meSLhBBxzWPJC06zTi3RXgZaULroIQezrDrBNOeIQvDnoheqzCdFFz8q7ijwTVZ/8x3gh9ZIftTf8k9P/airH9ybwCb+9H9vmuYTf3HwT/3J/wC4+Kf+1vj7P/PQ/wCaF9o/5hR5e0K3T1Zp/FBPX+Pscn+z/FN5p3JWn/LVnwX/xAApEAEAAgIBAwQCAwEBAQEAAAABABEhMUFRYXEQgZGhscEg0fDhMPFA/9oACAEBAAE/EKgejKjCH8iX68yv5D6VNx3Khv0qa9E/lzOITiMH0qVmVEPUwIpfoy5f86gejCJA9Kj6VKhKlRhKlVMwzA9R6p6X6V6VCNw9DPoH8WVCJBh63K9Kleh6kv0Jz6c+lR9AlSiPpj0uHpz6LAlenM49K9L9D1H1dxqvQz6HqEZUPWpX8K9T1qEZXqS8yoelRIEqHoelSowaiwY3K9Fj6BCPpXpUT0AlRlegepAfSpcqVMSvQfQ9QgSpX8A9B9VgypXpREhFly/UnHpTKlerCV6X6AMIqJOZUCJKlHrn0P5HoSvWpUqMYa/iTn0rEr0fVlYgRPUjU49KlSoEIx9Kh6LK9VPQIwj6VL9CViVKjD1GXFlwlEYMoYnpUJcuEPRIRzCZIZ9Kh6lHrXoelSpxDEu4yoEYR9K9SOIOZiP8a9Q9WZ9H+ASpUBleqw9D0xUP/Bgy/U9E9L9LgxqYi5hLlehGVL9T1PQi+pXoRfXEuD/AJXqRPRuVE9QjB/k+lxYPoRIMYG/S5cGcS5zFjAhXqHqSoypXowYwlfxrHpiX/Af5alxqXCXGHo+g49K9CL6JCXL/AImoxfS/QleoS4wGGosPQJA1GvQIy2XM+hOPS6lwYRYPpXrxL9Ll+lyoRly/Q8ysetw9LiwZzL9WHpXoeghFiQhLHLiIaRKalej/AAr+PMJf8BjL9MypXoTmCS5d+h6Esi/wfS/Q/gS/4HoelRhNeYUgurxLpZegLsdez1lNqhuzpEBftFj6V62y4TUqVXoTEv0uU+ty4suX6XLl+hL/AIMelenMJfrUCV6X6Er0uX6EsuY2ECzGfPDFzCXDXVzuV49Tj8298PMNL3HyV5PuMOkyiOxOJcH0GLD0uLBiw9OPQjuXCMuXH0v+Aej6kYS5cYsPW/Qi+gSoeiy/S/QLk2fEUVIsFvPc8QKMUAbt+c2MThoaDKdDWTk5iFmmCyU7KfTHWJQRwcPF5lESvU9bl/wuL6XLmKgxfTUuDGFziHoy4Q9Liy5cWMPTEP4VLl/xCBOZmAphoeO0X4J4UnsxGVWsgZSCjIC9gl8Q8Bq3XBwN2cPJubeVrsoMJ1EisGVa/icep/C5cuOPQjD1PW4/xYsqV6cQj6X61/G4PrfoS4vpcue0vwhMnJ2J1zqkz71+4EKCnwPPJCmwMNs13rcqPRR1FC89HcuSs0zC8fs4llFuh28DfmAVX4Hn0PS5foy8y5cuXL9CMLuX/C5cuXBlwZcf53Ll+h/I/hmY9LjsVd9pawCADtXZupkAOwJ8SllAHCZPa+sVSubMPNLO0rpQpNZ2H6itQqloicrhPzHGcRuVtJ4OrxOHA0dbP0s+IkJcYfwGXD0PS/Rl+oy4epGDLhLm/wCD/Gz0uX6XL/gwZcuC6LavrxmDyymm6U8wey3l6/ELtdFljb44EF5PsDR5FsIlaXNWHyYyJj0TfP8A2403Awb7o3XiFSZQOA5rvykpgA37Db2fzF9B9b/k+ty/4MJcfQSXCHpv0ZcuX63/ACGXL9Ll+ly/RrUW1dR7q4FjzisfEpGq4HF+LxcK5VzhS+Rx/UbOHSAtdBxT2ZWua1U+wqj4iSDyf2ciS7ePPjyjXhxKQyQOXQDp4uV0V1TYJ9SjG3Y9UvyB/wCFy5cuD6X6DF9L9L9L9LlwZcuXLly/UuX659Lly5fpf8bivUyxbV9owDMHJkrjq8wCxwkVSIcmxOkHhqg/Ajhr5JW3ZyAi++T8xNQqtDHa6aYcoTs7exfzTLaf4ko0vpdXLbhUTDIgO6aHtmVIKUrmhb+HMWq4JeIS4JGLLly5cJcv0XLlwfW4w9D0X1uXGMv0H1X/AAuXLjCXLly4MreuVUOLnATgF2cD7QpdIyvIYhWDLvgeqOjHiFAWROg0+z7SiPGEgXagT2JQULsfiyfMAZvKPxVvk94GWJfu0EexdyhhtArZfhvZFAYonXIfGppltxZcuXLl/wAbly5cuX63D0WDLjBlx1616VAzAly/W5fpfoy5cuXCo4b2JgckSIsYytJTfK32z4iF0HYWPZHcKaPKW9gt91kQFikAdAbB2g/KAooMeG/IwbtGSr4IvvLfBsL5Bp9pv9KtkzZhUvuQxcBchQYF81fzMYi1ddWnwe8ps0wYHVRAOcwcSlPEDD/typsR216363/BRZcuXFhcuLLgy/QZeIAFvsReZfH8b9bly5fovpcVaqqj9iaTvHFsJSz7X1lBBZpZT3Lwv4HEHMRYE+ak+IrjUsR7b15ihWFjdA99j6lLWuPD4LQ7YQ/YyRhydyyJLN7CL5MMPuVMRFKKGzeRenZHH10MYKt+5fiY4ULWhtJXTU1TdqFKZoD6tgavUEkWAZVo8REvxFmusINSCp1uK6LFiLxdGJcZfpcGL6Wy5cGXM+t+lwbcz3UVlBLP4XLl+lely/WlIbcodInfvEm3tuvmFiU/UEP5TGOiQse2mcLJLC9rrOzKh1xc+Vb82ypXTlCC+a3js3HlGHLEvSoe58xNhYFz0H4NMymBMaKsga/SQkuhGi9HDm4zS6cllT8VMCioPZmzzCxcFPl3nzUZhCigC2s+I0QEjqLRSdSWhqj34l9pbNqaBvND9TEQnTzdRMUW0DwO/iC8YVf93gEu0Nd0AAsFrwFFnVcsct6WXp3iy5cuXBl49Ll+ly/S/VxAVeDtfM/CnOYpIcBV42sFwreh+4nlzzCxglS5cv1PS4vrcuENOmOLURbVrioAqjn/AGYVKmO0Rwqg2WeQnkjXKEtnygJSQCwVPJRDaalsmmGql9quU/R05gPHZ2SpahGK1FKca10OmB6OFgaMYuTvLuDjpV74oGnn0Xtovza6hsMmA6W8OcDUQ3VC5was75lvxrZclD5v8xNsOAimj6oiSDa/agBXsHzFyHQ3rFbo3io+Uyb0uA+bjpwKFacCV3VmGRCC9C2M3nUG1CTdnE75jNogrkUDHmb21RvRT/UswtsONkrErCwZfoMv1uX6XM0vSWfNLrtHBbHtho8Q4FVnhbrwdIa1wDAOll7ZSodMqHfR75lBLaVFp4s290g7EWFZHVDBELrHov0uLLly5fpcuLBm+SHsbIaoneoD8jl/ST2qXLCWBa41AiirFHlBfa6jzVKpo+DTuEEsFgKBeEd3Kbrk3qpQC53wwW6VLmws6VvDNResMLxnSMXkUQNlA1xePeEZ4UBF47y3qA2MsFnQ2zBAD91p7qDHmKKlY2UBWODTzHpbdAQ4OqrXhcBwKCCkmlX7A8wYrUTdGHO21r1h9PYG8QpaDEWA2E6i0TLIXYa10eJR8A6BYF6tmpbgggKS+mu5dyrkEJaLfsQwTUzIGBl5bFMGzKX1rMWg2gOcW8e3LGm3AwKt4P3DiOpzL/guIGhAA68ykAlbtG7/AFA+LAIOwofzMqkKqrDjUBxOPl1BVEPMmWoX1oXHn4mGE0VwdihErQ5p+6Y+QmqZPdKPBmXa6l+pYQMv1uXLIvo5BtaJaZCAmGA+YYuuo4YyckBnj8Qyo3GuGYw5Gpb6wEQ9jYtfcQcvZ8zIey+8sNVRXU0O1XJFHlSNiNcgpqI79KRwT8xTr3jKNHwMIgF1exmu3wuAw3Ji1YiGMIJFAeUNglMuLQq0c7cYHcjQwIqYNa9jG/HLAGwkZyXK60a4InbIMqCmHTAe02sqMqzlxb5jTtsKwR5pbYwN4adBaeWVVStVlDaLvK6zYwJc5cDgjkKVbyTA6oQHgaoKtX0HEBkGAvCS09WjERLwqQVSCdFfqFxgW3VuvwSimN1ecEMgitt8bg0DfEVMehg2mu0ODqwBLQvQvB2uEkNCja5YrN94PmeUZZqqBrPmAaFdA8MCgY7xkuOLLp61VMLeay5C+2MSj0U7uj4QlanlSe9/qZ4eguvarY2umOjXFc6ljL9F9Rly/S/W5c05I+dk2KS08L14lQQZcr8HDKLGhbvddO82i8bhwZzMDK1dHzMFEjqufEoRWidJx7Uy+8sXVVLamRvGKqIVAReC1SueTxHOCJtVcjnYQ9HRGSwAFaFJWoXJ98t67wdCNKsqpgvNa6x3oLFu6N1xyzZbusKitZaEsCAcuaLPNEtnQE5ADBDPobZUV3ZeV5JkBAeLzZ3jowN+FIu6K/BL7lbUwSp3KwsTKSluq74heKLLVJWPnL3hkcG0jXVZnKSrjLVvkX4i2eXq7CkXotrxMv4oPLig5AI8CryNBdLrgRLDlmFL42moCWNKcnd+YkEM5xuGjmiOR4XiWd0X7RY+VjWDozpYFBJXpW9y+dTFLC0yeQRjxiJAUqgN9XFspRsaCPxK0hNN/s/C4cDXqWb7Uv3jyrmrYe5lK9Fkpy+XMPGh7WQaHc2MJNrwEC/q4pbXNy8wly5cuXLl/wAH0WlvFo7ZxCGLNaxkIwowKu6a3bEB/ipRn3AEuImz1dL4YvDUuDMns6fqZdIiasUrjfL2iQ09ACVV1mvuChbADQaIPZpxw4h2nXusvw3VxgVXMdo9xGJdIVHYCubT4gXa9cEseygqY1e/BrCh6o0e0sfkUK4G3bVvYlNmggAD3Q6j8i4hmHla81Xmte83RhULyJ13qjmoIpT3s0G1yv1cs/DFzYKToI8wB6AKnADAGGn5mVGmrV8SqtnebsAdlUKelEwFIWLWQ5YEWM6LwqwAuzJY8NNSu030cniNxU0bFABVZaMQgKpLkxvnlvnrFiK26Gx18HXeW1kAqZ1WukSYqtlcmQX3l1lejCYF8WtRDCF431zDn3rMoBquYBjZIzW+faEKhfhoWHG89o4gkAZB0Ws94Vtjuzry4HpKmxKAYV9VZKLgI5UV1oWfUNUDw4+EB8I5Rot6Np9QAsWbuW/Z7S7dngT81OJEelRAQvSD4SJx1nNAdSL6VLly5cuXBly5cYML0RyFFnU7kYmxnAdkZ8tR9qCJUiic4iZtFLtycPhh/GaMcW7fMxKlTrChE6KOzqQB1jMPYH5mNMeZmlsMRqikZbWC1wd9RA6BExVsrrZnmBshCyV/dkU0I765B22hblQKGNvzZAMAoOyaobS+OYRMiZqiihpgbXWKmihNjog6BF+WrlkJRRuhtYSUsqy6mL7q5xFvqhbyrpB6ggIRJtTpgr4c9LiaEwtrdcGay+YIZc1srjnduD5jMJk1CS08KHpK44wM0rodNEDOt0xosPCIfFgq1LBe6r5iq4Dvq2DvCdVeZ7z7vxKfW3ZCubChRMxhYFtCyJMgX5hYAiFxhha6SztvbNFEucyFWy6z15YBgbUbmtq81OEc9VUWoOO0ZgfALnq9cwgrhsr8lHtLra3kfFPmXIWyLD4gMDTose2IbWplENZDNdpvVDNlt6KCX0uLRtuOp80LLG2db75f21CVWdm2HsGU6amN2DrLruMOtSyoGK64J7wwQXqLXN+h/wCNy5cuXCQvLLj7xLsgy6k9jeu0PZNiGpqwNPNa6R0FXRDgDguTxEJbKA5MCnUdkUxUvVx1Pd5jEsCoMPPs11l+i2KNqC3e8RQx0Jtr2MWRSBr1qwYVWAYYFnkmxpToOZ0qS60Us3YOZQ0guVRzTxgOsQYBBnKUTpdpxC5zcEAKp3G8vGCEUMU2qFfHMsuNIVrKqMXUOxFSYKBIFd3Hi2WI3NRSUBbWrvggWhZ2MpxMYDtVxGAhu68F9QvzMjrqsDkFnS6O8JTBI6FAw3dFQorMsAF99iwNNghVZCm8ZxHi0NB6IHTuMUgA9Zgc8mFqpEtwirQsfZF0fJHAHHllqaoBTQiW4Db0ilFotQcCNXvAStuilU2GBcAZzlZloyrlRay9VwQbDgugs7YLuEFBK6C1ttdD8wcM5ELX1zl7EALdOkD4Sbz5SVp92vEMUJlpQfZb5qIaoKXnPdupcq2CgS65RggmDhQPpl0p2Cld0P7jqFdrCC8Oz2IUpbbsoX10sSwUHpc/uZkjuCIeL35lictvO/f0v0uX/O/RZcZ5oZg4CF2JTUKFI9dYbEuUDptBOBE6pLUUJVG1Lo+mbDLAWI+7XMdrxttBcelkNxpzAW17DsiEosjs9jpde0Q/ZnRrVvYPMRSDi7WeYabIATRYKhDtYWW6RoTdlacaZll4ZDoXXWVgYBDaCCILMcNsMBeqmNLHAL5iVWCzSKgCtYUeqDw9uAH+do1osFboFQ7VubYBZrQJJ0G0OrKejddZmuwDvcQyqyGKhScXSCKHiJSj+LCUiBS8C6gCiDZzk2ec48QFyKkOBm3QxXdgi8sNFh07xJ2ZqtaoOo492W2gEKLItc2uF6QZwFSAUewdNEpiR9uRw/QhRFgcqmVTGH6Q7Uq20Rhe7+JdKAAPO8EwxrWQTdt89IbGcOC/dqIFsVKW9yrfMCVMcPxJb4MQz2bcPr+5mpMsnsulIQDbAHxZl4gYEByeIq38xhbX2Q/qWAzt/wBuahHi0hDYBvDQcXx8zo09iO5UTx/C5fpfrcv1v0uJrTm+l/mGqQLBUdLIzy7aKjNXtPeXUILAOSY6Oes47BL6GefibkEHkrD+hH4UwWzMKdDddI6po5wtrFwGHCqGSO0faNQriuEVaqHXNQUIz2IjSPbcd2AN4Nijxi41BAbWChCNl4fMrQe0pSqg5Mtx6TR11TGOhbfeOmfYtYUro5lT0LRVa+JflCTWy2OVNOCATkL2n8ExgmakqoWtUB3OPmJtV7dDiV5xfLcSGT52IDluLvVNYw4Q6XUJaVXhdKfJdQapPrKbWu9suGgYGKoPglrAcizZYZc59vMoVSoJyCrOE3ZvURqHQwd2IxlOT3lEIKthLW6dR2rbBojABtUMLwVg5eJhFtpgOD2Nd40umaIKwXWsfBLs1JU5uq4DpzqXLKBmarfUZa3KrJfjRfiIZc4RW8Ur8wVYLXxmiMOoZ3Yfr+InZX3PibiAizaQt3ND7kQVE03fjKJ2gEHdc0D8k3/mVBAnLgfqJLSoCiW8WZiZFWq2rLly5cuXLiy5foS/S4XeozQdLbP3AM6Mhqv17xG20ozGvbDXWCgXgTD21FgMBB0N0l9K/qJUNI3p0E458RtfAArXSzSZHMEiqSGgS9OvCRUA6CqrhePkjYDS9NgJfW5nxFLIULX7sTwWiPymNS6a40ygVLdLqViKq3dFH3wRyxRmZA0Hhob7xmQMF3SLW9URggmS2gh+LloAQwVyGvxGqlgCgZlJe6EF6aOMWAYD0oteYguGW6Yey8y5xckKKHqqxvEZnFoGXPD2iR2xwON+2y6DrUM9nK1Vtq6hbUSqxLDBZlTvNvdqBfUKVQkQZpAoeswMOMWmDyg23rEprH2TLDcYqqxMKUDUwFC83zN4C1Gxrf6XxCbmqlhc28uhnpKVommw4LvRzUd7sHGHi8rN662DgZb4o6ahaxZpMi+W7fEDAYcqx70XKRI6oJ10HDCQKDafCytdl/QEQY04sJD2AX7w4C+Gi/tisndY/pzDrT2Lj4VZaKt3xmF7JMM36XFlyz/wuXLlLzqItmdl/hl1BS7zZ4dxAWWSCrOof+w8XzEADuXZ2g38/KvPjswkoWWyGkDr1lBaUaWF9VoXxkiqhawiucYx4xAlLKLyXXYuM7mWcZwYnfnvBA3F0z3Jsaw9dzDyiDDQtYbOkxgIe7wQX0RrzLRlYplHC6PXi4XwAIOSyh+Ze7EKYRVB8A/Ee9ArY0Za8pc3TnVYWPkSk6KbMCK86CWsAwqsLKOLWvbEtRzQ4jyVWU6rK5XAcrbcL94txgRVY57C8QniS9ssG+4hBwqqFUPM0dDVoGrPg2ylKuCqoGAdurMqVluLVah0DmM/kUQuCVW3FvWX3JTXJRHjjsSuwp6yoc4aVQDcpDsVFt5ABxpEig1CEqqwtH3Am5oFZuzm3pWJZBQCljg7u1/BL6tFqWGwv7dRIa8tUt4sa+oNVnJ+EC/aMrqx+7p37RFKq6V9js9/mUXA3WV2XZDEExxX46QDLT8R1Gx0xMhSnvDow+3Hh3LkY6cseXXn0X0XL/hcX1v0uXKUo8qvxUGBViYtP/pHYUi63muDL4hAEVpte/uJixsLoPgCWSEKszld7pG5U5U2CvNIfZGEH1Ch7m5WI7uC+GVTBPse93kmYtKkXtVFDqV13BMBWmhTXcX0eYTTYA5UqntZrvDpiAiLBWaxs5JhFBrQvd0WMrwljXFpX5ix6FWORoPzHqJoCwgXTvExAuW3v4y6AqYRAeWVFKnhLuxEstCLKju+4qu8CljBq+FbqhXXcB4AcR5y/cupHDotr0YuEUBBbTojmuJRa0mmAtnHVhzBULLWttvjN+03BgBU1Rl1bogaCIwABdM2XcQ7QvQcANHK6N1L5XbDtMHJfNGahyQNVRnU1fJB2ItKwoKKWrBbnvxDC3NGThRZaNYA3ENVYNjjdo6EsKTImTboxtgdaAWe+tJX1cSCRbgToKLlk/W6K9y3xEtAwHnr2mOKeUGrYe3ER17JvTxEDLzOMaLKd40I5bFfb2IRlemJf8rly/UxXUpjQqqV+kxAYwTA88MSi5jIaGaOzrzGggtd0ThD3YhRslxs+Yu6oNt9qm9wSeiFunS3iVVtiift5gb4bRSnwgfcuDhcOwu8YGvZIC4xaK7LcA7K2ZJnWQGtUasaccPtLUbxdWt4xz+YhlwVbZwaeiY94FrbDXNMx3im9WM4P6RWnNbVDCz3vwRK6NAcWVOwITB0RlC/Z1lxOQJgAdBRo4IKmAN3eq/m1gUQRY0A4VvNMV1gLIq1k/8AvsS9+3JmvEQrp1ulhPRlc2DaJm6Me1F94iGKG+AHgxUad+RGLzdVUa1AWFioqww4ELdUGq2aQ1u7ZVpmCAO20GqHXENcKzdEAOtm+JcBhPIUL0MXFoKxRq/TNUO6PeMDFL2LL6jB4JWL9bst0LQc18wWhDjqhYOz13xGIS8oHL2dPWUVasjp3Z+GGqh06TskobN8zIXMGE+0Adytof1BNRJbctFYrywFwo+/Q/hcuX/4XBzFW0V1ML+pgTUvNh538zOQKUcmPmFAgSyqO/7iOFisHbgeLjJXyBQJpL1Z8MwB5KVW7+oPsGuZg2t9JVn0WH6lUKMI0FchqZ+ggjqwY2LY3QeWLOR6v5gC4hptLsdWh7wAYReGuDT17QWzyU7Ir81HG76kQGEelWshywJQazVXim2KGbXKUxdi6vpFjfKCtJC+mS0YV5U4tRPdhroRheYBhXinAAdUTLRRF5C56qUS4bFOpo37wPYU0ihQO0zpAkorFDOK+JcgDQNiO3Q+4db4otgIlt0q8VEUiRzYQMUMB9wQrbgbMoHJ7+8IsfYaltBvB2XqDR0u0QWwF64AtcEpllgLW1YW32uqhVbebp282cvsTdIXdGt4dnyo6W1YKPlx+YZV4PCb2l7Xo4hQrRamXzGiusKZc2PY8p0/UbBwiUF1Ur98R0/EKITpGT0zf1LSoVoijmrfmZBqHxaFcYg+ly5f8Ll/wuXLlwVUu3Uy4Va4YELObUj/AFGkhhtKJixIySrC0X9mNwMoFkFLkdAMyZjYZzsK2NQZ07Qt5uXUbQ8Ee1cx5EaAjXtot32I7MRZIVyPJDNpC7cKf+kAapo9KR23k95SybK+rToTIixc6KB+oYANrsxb3F8TcWp9rV4et01MqwtTQC26BXzClIFdaKt+ACI3yjRkpAHJmpdR/kirXNflzC2OvNUDAu3YcGWXC0TduROs6vnoQisByq1hvLtrmXEEFo3bQmgxcADXv4rn3cw90Uwoocpeu6x1isK9g532hcU7mcT0SoY6GWAsDoQVFdXEyzey6/uhAdu4ByweV7leDi8aqW8WpSivqdfMMSTaKUIzpL4WMVSioRYNdEerxBum/bVi42WxCBWnB4oHPdhIB3kVpfLGS26wZ4ju4jHbxBEKdCfniNgs7E3xLxKz52Oxo+4SORwKDxL9H0f436XL9b9BKkDNKu6ZSAKBC1+3EuJKypQ8kF+sN7peTp0lyRL4HP8AZNliVHXNkvUFkqaFMTAEoCjxeyPRzugoFZeeYiWcBb/UVhCTForHeHoUEBVmzvOJXgQDpZ/fMGTBkzdufhFV3BjLG5VdXRdFva2AIZAwnN8uCNrIQ5oo374I26DaS5Rk4Nse2IKecjQ7XRBArDKYWqg5ri8cxMn0q2eIe9LDjmIWN0GHAdgxnU2srWsu8BOfYspLK54z3gmbJDYYC+kS2JQqW4yoUHaGdDqFugBVnlzHDappVR2AFfEyMbhpRzWQJhQ1DaVm2H1zMFkFAXYVb6sQtocLl8znwQIJuyNI52HjLFqNjLi2gDb2sjPdhkHOCVb3uY1sIKUK6DQS3TIygFOmRqUCEsl2riu8PGGUW9nRFnOVYofG4F6BNE99mZkyV0O9OCIu4Fwux8sT0P8AyuX/ABsioq+wc9oArY5Ftfa9xAZFMWRSgQVa32SBXKEWMq20l8XGUOVlcid+kKMFCuxvl3UYmwpHBLN9yW7wnXjdsonAHjf7iaVuBgrbO5YdSMreQf3+o6lbajd/3Fq2i2TifmEel1rDf/RrvAyxcKWnih4spmAWmp1Rq+Baa6QVlagLnqPOpTtUqlDaALyuewSmPZFmxt6029qlZuF0KOTwHEICLKXb9swmCgFewdOrLorJKos4Mb7xKGjQBdXopWPDEYQrrRU7XLMEKU5fBqveZsJgbUHa7V7QvCFmcI8UDXvFZYZClh0GzHhaiRWooCwZf/qA3BmDu6KUvZog2giiSu7VWOoyyOubinm7VE6zylp22gPFwBHNUfIY+4znNfICYozl7s334a5DNIRktt2L8sAU9wIPgtTUfujoA1XnmMS7X1P/AAv0v0v+GZVIC6WKC43Sun2TEcV9z+pqrCwlZvGsMvnkLurN5RLGzcFX8wGo6hgyxW5SbWm2thvjtBYti2BMuV56GMOMs5uGuDg29NQkMfUu1xbRgcjkgLhzKRAEV7koxYevTrDXDdLoC8B1wQwTYsKRGW3GyYpSFXkAHqruBWSQCqFGPF+0NyzIqQ6vgOWEYIVShlgcDrrUbhwhYZC9so06guy8Cw8Z1RoKd+kwoVLVtF7tNypgyjUx5B9QlUnhXurMzZMH5h4io1bgKK6Yv3xBjqatKztaYcAMXx0rVe0onhUJbDpkD5hjDecC+lAHdm+Y5bAdh6LFeAgTTgOD7FZeInvMhrJfamviAAZi7sMdqfMHAfKkb1hcaqL5cThrSj2lJcZF7rhQtx8Rw0r5pDs83zL60l3QTs9owS4Lb3MEd/4Ev+V9piAujyTaHtQ/NQK32y/xLLBPOJfoIdzILdJwQQtQ0MWZpZvFSs13blv0LliuIMr5aJfcJX+hsUCb4HbJOPrmoHgcREpAhbGEXjrN0ytcSVkMq5exzLHHfvBohOc2cw9QJwU1qyY8YvgjbcF0Ucst94HINNOjpdbzxAUKbBVXQFsrVrL0gRn9KNXGavmW9hI+Qt9CsasluTQAunJ79pVMsHHYrodWg94F4DOKs7THNPPMO2wu07ufMLQUUovQc5iIKbwXTyxA6nZv/kyEBMiM9lly8lKFy2d13DET6qLpu2VkZL5F5p9sVKAI5AaeEz5haLVSflsPeGCV1SFXkflLQNDI+28HvH3s1CPswRKZUlY8WUTrWplAAtwuNrIDjc0GR0ttzFyF3SnwoTMqU1VOab9sQaB0Ps8M1LeV4WA9/wBy0eSirPXuj7wBrrTMEiSHQXXoety//FKtJ4xNF77f5lj7uP6qK8v/AAZYDu90A/kIEpp6P/2FF5e1jFW6U6uWkNtXuFRMNlK3VumICoaF2HKnGe3vKb4SuZyF3e5piLsVm7zoqZ/IK5ySsuY4RqONcLdwWEdiZV4oLfaCKVHYrWUa8wZx1sa7nmXhjTBs/u42SsmjbbdwGO+UbtcPms3ibYpgL+RRR8y6a0R2IUqtXiVIClUxSliWcWnQp1juRFIvIeyUX+YamivicMAiw7pHhpK+WL0I1dBbKWopcDhFrHvcbsgqrKPfhAKpRKTCOx6jKtZc1+27TyR0ELvFH335IhacoI5M1x7bgroiAEOMYuxjclVeC292iq6TGNEiHneta7rD9OYnWfMJbRybOr/UwWJleju9XzKU3ljBydtnjiCogau0dA3vzDsYKNKrsy1ivZgD+Fx9GX/49ipCvwRp4bpP6ZfqVcg4+0hctMPT+6Yqs6tfQTOaZ4y/qYlU6WQyC0OauKNVL0Ptple0woW7U1SSzDUKcPUNbrkbhY6bT6ATqQa8k1wGi0tfbMO2SMjazu6WeINWwNHIf7lbCnDbW3oRgA1RSsqVGc1jrHsgrOB5LDv9Qw0BeSjNyupHBgDBWaL95eLlLyShkpCvMHwJeQAqp6E3CrSAoKBrA6GtTTl1QGq9mphGjZ11RA0BcCdBggdi0725IDpDogrXIY4jz9ihI0VdjuTrHbQc9JjYJv8AzNqCw8cxjmAcF27mfIxre+yYJ4zBoLqZqHYOTtBKCABz+OfMbQgadJe/TxHoG5QT1ms1cI4rMYD2GpcQgOga86ZiQTdlU7X/AFCbIUFZ/BKoo+M6czE5C7xVRD+F/wDmq1VsNDqnU8vvn/jsTwGX/YfeVnz6YOFeIOq72TNk6t/NxnNr5NnZl1gD1IrNnJtT2hKet2D/ALmbfrooXsXe+kpR8OdnwGSOc3G2cwlTrgujzCjtAUFcUpCq41HDvM0aeC7qJG42TxDR+C87i0QpMxYdaVjio4BHEKSilOOdyldjRbzwb0wrDcAKVY5sCMO2tbgHBb0lQ0GMNfi5QVGV1tH8hcw6AKFrA0/65eDkcRTASuEGqFoVuOxqLbMHGXDfbUqrGBGvNHWMAoear/5GOq/6E0kcuAiUZFKrpxL9IA5Kt6jrM08DZLtZ8sR1LiL6WCheijoRwtmwWnHIXXtB4xEKEehQVK2NbGZ5AJXi9OmXvHUwDLUsVPYSN9IFC+XJrB0H5hHK7aoVXvjHux8RMwoPcmH3m20aseKePDFbxYu0379ZnAhRL12zKD/j/wBhF9ORw+XQ7w1KG4Q9uvf+JgunsLlDCXKVLt3YFTHixj3J418QhYrhZXkJTlwpq/pqBcygKHd6x3hGbdaUEetCIdWBBVyQiPXIfaMNN0EceWSBAI5BJ0D6+4gCTkDh7AxDQlRaoOA9rjaCVVbkoY3xUGo9KOvDh96jwwCy3wfG4AWhqwDVdGYghweXVVwzAiKVe8nGjvmZSjA6LHGYuL2Y4vbBw1aDVcnu8TENb6VoTtWZVXtl2P8AkSJWt1O5HWzNqT3YtKCWbVXlZg1waaae3eYwBMD3bddS6lrTTUXTw2IZGhhzrxfCXNukKUo9Ltpjo3GgLflOPuWbpVQbB+VCUHSbG3ydYRDGOAY5TmWuQxlgfeJ1hepbpThhDtKAyxrWFlooz05X3xcEcU5or7uoy0PDzF9z0uXB9Lly5iUTExCgqOwbrz/UyFLcqlwryR6QxY90H6lOE+P5CdIHwjKnYlSzeG/OIkovq4m5VXzHqpuZgw1BjHoTTDooXYgnZGW8AtAFe7iAXcWt9gBfeEygyl3i+LQX3IGEo5DYdac/EUlFVjaujHfq1PFAQ61jipQYQpXNPPepzCBd/HSdiJVuD27kZShoOAXw+8eW4t0XV73MvNbRxTvKRFYLs6rab3qVhdWBMAPHnUGpNKQ2OrXBxACQivlSfVXOsQb14l0KOgVtzXNRHSPVKzOcU6QCG3WjDzVKuCY+c3N81QsRNCZlOMC8t9IGQMwNre9whzZd4FdVxNvYBVE8WPuKCg4Da9wBlTfoqWydNwCL4Lvscn1CQaBVKKPHfljFwHk2/Dv2gZGg0BxdrSwOpIBvwIcJTVmXslPaMsvLSvIx87iWETOQ2PWYLYVzH6B/Ps4oK+CYzSefocv1M9zgR+FHvUcMv+W78wbhf5cglBQPa/kz/KfqH0E/pmFj/wDCggF+ivxRPFUCfliMmirKXsGIVG9sxStPulTHgPVOPMFcdnTI+YsnjZW4wtsK67O7dS81p27D1XRTCxqBkzvrjESOIBawqzmHUEFQQV1OpKOgCsAYMYGmJqJQDQ2dyowdmVK02moGnUJm9047kRIFIudvDiP04OFCUqzupBUliAWvxxUS5sCNdeN9ZRKBQcNHNVxGVfQjRlwDnvKzGEWMhzSdS4MOAydU1hOWdNUC2V5F17SxtoWOR+yOetaELnWEOpBCv2WDR3cRqcLLkK9giRMEqlvAX8yx1Wq+d1Tj5IXM0GMk6tNpe6Sg5jqCFe8HlrNgT4weWI1hLVVb8FsbqHKooHSms+8EN8RvlPND+JSdVl306NV+JfjXqXjlH9xV6mxQ10FwlunK3fgQqpgjLo9ot0G3uy96XFYDETaVmVKlejDQH1fwUfmf6D2xSUFtb/8ABqCbawUleYOAT6ZYpQ5VcQtbe6NUQv8AzmVIueKPzBhcrkiwdeBP7SHKpYsHRKPtmVwlo3e6pH8zFTuCZr8MSL7liONbvzAAllMD60eIro3YWvcT/MWFw2pRCBzTs3+p1wdNu+vjUDD2MnJqm75viH5nzUa1CLSzhfHERCCqAP61DEWiUqKNXafiVcqMoMt4GFpvrEOUuySsnJgV1gm4F1aeKz7hxkdILeGRzZCawhZXFlXoccxMjqlSNESvxzKgYN2iji6vuiwOdlEDgtrsjVrqVqJyU3W8MNuVYCV3CAFBg6o4RAT4gVgOWJdKtfqYAQMttXQ6d4DqkGbB5v8ApEarBn7xYRqUOEAJndKQAHFLs33OsvVCVYu19LvJLAmudKPiY9GilKdE7RqoOrDVppwAbhZRtiXRq4pi+hArZqYFsWDqI4ly5X8VrcKKG6sj5Co01lw34tfqYBLo59AmwRzbftWHxAfBPgKWUYCDj/VoALcc/hKl+UVr8RCny32TCLHkBFcuEijYPOsPswSoEarQ9yyu8dWe90Hi1FwDNxclUpmrSqvccutAUsHsFduYHw7yJ0XJ4GHqnOv2RKYmazAVBw8xwFioxix4xFuPaltpZXMUNbvVWPFwIdGGVdWAFolHYurekEZJTyRw5zW5oDJuiBvBYYjkAmRVA8Lg/FwUhpTYr4trszOkLEKYeKNPzMqOzIS1qxrxmMMGsFZb3ur8bhTSHLgmg5mqNJKozgODfEO1W7QScrtnxLrPfDaj209Lgu5EogrmrzcuEhoFGu1uXll507GAU4wYY4NFDZw7tiPhTYT2bsessViooFL7VVeIIO9ZAV025O1QIGQrCLpbVMJmztrXWv6lOgFFhk++YgKuJ1lfo8BwR3zRaX4gwhZujjzCqFAzqKxbYqIsERvUVf8AConEO2C92/aHt3GXonadwh27f1J/AQ6yNe0O1j7VNnVcY8Nj8EWCxAmPYUPqUuhRwOyE92Fyh0+4Rde8Jxbwaj3W0HLTwge0EdreiMN8LkdfKSknk+sE/UZsjkf54mMAyUUPgZFlW1j/AE3AvIGn9QpoUpo1Og2ERZo4NA7IC/aAGPyKU6oaInJWtG/qpfnaMAhZOF0CV8y2tgbhcLT4XzMMHQfQiDrHLS+9almwDFKocC77zYLXOauq4xTHDAWZLdFa3LQaELLe+ktQLbIs1kGIkpDMzvFjD6MT1SsUDmWkWGcGOqN57kqA0EMYe2feJgJkKa61QMYWRYG9utn4horYilae+fzBsl5eU8Zq/iCTlmH4JhQcgRj+nbQuD0aNQDp9xIA3WaUiQgQ3mOKXf5lvUClCDzyeIqtu82u5ENEaxWHfME7dNreC2NZlyA77YlrBB1hMq3Jgi2p7HNsRiehL0C5o6cRWRYSVQuvxALwPMzZnv6ZVGreAOquAlWugx9ox73EFNTlcD9AgI9QNXky+z3hLD7K79p95Vp2rnqrKpIlhtnlg+c9pwmTPJO/hqB9X4hxkaW/GR3oedHsh9xg0FzVPKg94Yhcnb4wnzCTl4tWPKvowVD8aTpiJx+CsD2Y/Upbj/wBgqRN6L1YG+oL8plc1Xf8AE2nwQrItYzuc0YaEZctqn2oi1oayD2v8xk5UujH7/wCSkAAcm4CqqlVU8IvY4ygHJqFbexMIuoyPDDegLxfxCZW60OM9H+5QgKLZb7HSWJk0IeBt8jCDhowC/J34ZpaqovM7sXq+YkzTgE7F9feK4mNwu8YB+pdle6QodDLL6Mqyw9gxREhhBtxwqE/EMoVgoBffL7lCeerVLq7l1NGqP0x21C64O4+MssoFBBR9qj3BgBh1yjAXeThLPYpClOHdV8xMvA9K/wCu0GwyBQSn2WyN2/0b3Fjt09hZ77mE1uC9MtCwaXt6Sqbjhq3SCrzOBtZag0wbX4nNKPaOShmG/YFB0l9AY11iihOqVLHEvKNqwtOjy99EGZOVktwrag679ZpPDrwZhtKmBR7cvdthEXtoNrEY1w6uwNvYHiLij1UKLzy3zUtrcUgN85faK+UnL5YiStNV+w8EXqt9V8i08vaW6SaD8IDywYqcIW+7X0MrzMRa/en2hyu65fR+CCZw0LVXFVkgmzWBbfKPy2e0ZcxyPtWfYCVwfLHI5V4PMLC4V98we7Dpa6wAdgCr4gXOHdCvEAyt8GWXmgc/iUPJ5BB2WX8EpmDDlvvGswpZfKx0i0AgZhansEdZBv3S/Xw8fMdoXQNuib8Msz20m+p1HzLuYHWQxi7TxBqU0slT4HzKwNVLhqnFPaI0U7YPurRO8uwsEyK6DHzLf2Xk9ESpairYGI/pj9C25T/LhAsM2v4NeSBgS2gXHuXXaEQ2UmEz1LZXQkeh7ElwZTSFjvFHIUq5FNtMexjanb0xmBbGiirrrzcQAWLrLvZ+oimhkKLfSn/sR7pbKW+9y/sjjowChy89IuqK6H7i2sYJavuAaFuU0dhhezquiYKHKXasnDNRjSHECQicUWSiD2HEeh1AGAtUGhfgRKrbK0vc6DvtlSoTDVCeheO72IAwNQCnU8gdXNxUl7S35Y0FsYmiyql2cvvREsIcR7b8FsrZSpwPHJ4IOtTIwOHdeKlsjFB0PCZ+4GRryrZfLlltiZumD63KowGzA6qwtUVoHxPHvuZr1VXZN3XfqyogtoMeyLQDlUIUacpLUdS4V3cdCZj6cSArOAx8LhWEQ2tF06wRZDLZXyHXpNsiqK30PEBAAMG3/wCv0QJvcvkmL47xlBhGxBcFdszVJDjlP1+IymkFLo/2IVWppZfGdwUGjoqk8XKvAG9ReuHDcvMYtF5xVNNQPa6Mi2WXSdRyReg64t3gmMh6SgJ78y8hEoAhTonLH7F3WT8mYOZtKaFO9f1AcLnGPnj3irGea6F9yxgeiGAb4rMWjUWUNns0wSiZYosFXVZpOkJZUDXNf1Fk2Kqyrhue5mcZRDkdOb766yiYcpr3yyS/nqED7jBhAJzXkJlKd4METzLSLRaaLfd6SpqXAGKrgdlhGIRw35mFpiM3lGGOeEBvsEDdii1a+piIOA48y4yRxaiL2ibgvc6xUHkidrXuj9OD3leg5qGBrurx3c8S92KTTqwfI7qBUDvGh+ln2Yg7XdL2WvbnvGQbZOByNB1YhAJ0Ubaa9z7EaxpKVR9AD2XvG7IVoYo6AeQfZiw5dmD8sfVHueCj7jbFLIvPVbWBloZ3u/dgYTpQxo2/T03CUEppTGmtUONAmaAaPp29+YQgqtDk0e8KTKjyJYex9ymhdN31ZahLlpixsPJEJtdQreQ7B0gpnW78xmCUvKjQ8Bb5malgR6Ur4uCi2DD2e/mFZC0QQIla8xQMgpNzz5C2+ych03La9rFsXhbXuuJRWBbQDr3O2yLbAjRS7LzEA0h+U0YfZGVqAGPoPbTLJznlLHvd/iWDB1bJ4HftApc5BmvG32hF+IE8Hl7kzBrMr8P6iDyj2FcZqWqY1ms7Dhvp+JTjG8NnY+epLUytBVdnghK6XJSAnjIRQIWiZt5VWPkekfxoN68nj4i/I71nCFh9oFoouhso6FTN3C6Fe5GCpeusHgDRhUHALs3k+ZWtdyCjHeUNtLrB8sqA1w/uU43bpk94LpDXAmNbbTxUZBVHcu5u5UqFG4Wj6XjrHrtbf9xByX0G/wD5P8R/v/UcLe1+Ox2jtgK30P2vBzCVEFe1L5e2iZHrhcPPhw95bcGd1Htani7JRVvdKhrBVeufafDA6+IXbHI6EfmIvDrnzx4H2zA6FV5B+Z7UTWcwupw93ESKvKhyv/Y4wytZ5+4rQz1yxTYVpi8dre0ArpiysNsd6PtiJaMncGKXt+o3jVtHt1/cQV4C9W2f6jmWfCmX2sgjtN1DVIu+5Kuba4A8L2azATgxnFLp99QyKOEP/SaBTKaJeGCA5LUO46ITusJTxcfghJY4BR0lgXaiWnY5HS5RsrwO7XMCkbz6wxdsM2dq2N8H+4mh2zbfphTuPiURmlJbteEfJNHYXIBMdsxhzVYMcf8AUGK93ZCni0Y9OrApfxN0DYLILwuJ19DY0va3ctnawrLusx+JgJFifeNV4hbi8C/J0i82eBX1HIqco0fUttlvTmAQRgaCXg9il9sQq7Dqzh1YAVCUVjL1hbEjDbZ7RqgJVjL8ykSqcs3Lnx6PRrq9DrL5WAodD+3mc6Grlq6Hl+iZ1x0u/L58a9DQWrQd4ANbWvtP6HaeQzdDX6j3lTPiKP5CAoDu/pHDeXxMWQGEagN16OgdriCEYKa6PfleXMIbWVuOD7JagtVrv+oYQ/ii/wBIlplAXtZglzjLamUdCdtXV8RLDZ3f0rk+JWAWpsNr206Xi9cEzFoXsuhjxe+WKM5d0Oiox7TClpR99+/ScdSPAdPN5WEbpj8P7iMhbJ1IzYDmnH4Ll3mAc7NX1LghshR2DartKg0aTVcIeHjpC8CKDxfXprw8xjgBhP2E+xnL0rYHtK8gfCJ8cd4jOtQ1FoLYvpeIGGqWu/8AjFh6w8eWxgOzeuv4jP6MseubB/ygoKTBdXh3T2YUFrDdjwlQTiDBbbbzfzFim3SCy+Q/6lmgIapXtsp9mIBveNs9HAP5jOwSy/2LOTuTDCFI8noGztGVjjnLjskbQWOZRCCZVRLBahgoxDDBfRgvb29LgAK1ma+gPBi+8ZQo3rkJTC0ZV32jpmuBLQp7yogR3XscHvDJHQ/s/UsbbVHAHQOCVKjt6nsHL+pucVHbv7SwaQ8LXzuVBSIU1fxBtLdt/iYTQ4uvzAcAMK18F7YuINCOhLDzyy6yzJdVDijkge4v8QBsdzHGAlnniAnZVYJyKnQYDpTh3nNvYMwFe+hiL6Yq0+CGQrnM87A7XmJwOF15wmMrBodTFn5lW0tTfHH5hKU2KJ4dzA5JF6plfeXD5XsP9xtVQB1AXwqe8YQtbfZeXvAuFknbRv3CPCVqkRXsHIQxLhRtmuouGLoop331MvQMniVwGlc5aOi+G6YBs3dB/wB6SnbIF+e46qyZahYrfI0lZhVkFiq12Kae57kcAEyYrqdBBRSu0APJ07bh0Ab00W+/MCwG1WBBxZbqV0xRWRWhdOjK2y5YXfO3fcmiWoFr+efci5fV+TVXLnThBo6s6sOzUCBaNe0TZArQ9oOrcOSBrJc1wLS8EAjawA/mUH3GP7ktyDIwLMvEDBpLFrOhiQyeahBemXwRdxtz08SpXpUJi0Ae2/uYdf2DfzKlSoM4fmYlA1iIW+WqDPdiMiTkw1oeWWYLE6rAOH3G9L4OPwTCgA7wLhFHSMLRXQMxEokZTb+A46ysj1HKrlXyxQtAUdV1GLM38d4Ab6A7537wAu1r+9/qZo4T4GVDZY7Wf9lwLTeXqdIgWiWcGV95qcUPDj4xGCDicV/hbj5gVbsz8x0YoGS3p4rJC0AYulrgPTrfGY4Xhadhxx1EaQTTOVvrvELoK2MaO08rn4TFO+a2B1Hp+OYgHBojq+nchZTTaVaORHcLCohatrizZ0IioGV2VW89R7Y6ktdAkNvROneGB7RgrWv7QiNhrL2N3/SRPKVEdO+RWekCyAugDF56PqHZMUoWcg7GFIGxiWG0SN64FNvZrDKxxUnFTwuq/KVDTdIYruQBZaw94qi7yVmYNQ8Bv3mpxVEpZnKG3qIagxSITD5TemJih3dio0a/aOK9X0SpUqVLPMRyrKlSoBDnweUOFe1MI6+cwji54Dj4mcGvAj8xRuCIigZ8TA2X1igHqPKOs0dFvtEvm79o5vRuxhrRegcsw1TrXeLwhbyxI7HHQuq+5U3hX5fqoiW7edA/EqrOmOnnqxxmQNbV3iBY6q6i4RirB0Or2lgttCOF3Pa4huWBy0FzzbqFjU0Gujx4ziJDFzacO/MNEmy5DOP1Cm3Zdm7dE4YIVFFeYmx36krAZLDbwoHTk+JkVBNbHusf3BwgtmawWOvJHtCach9Ujh44O5TERbB14G+phlfuTayysofdfEoqqAxAnbL4cRdjzY2U8lcQnSYaij6bgJaXBMrhsPzELhH3LOvJc32O7J1nHVw0q/ERE500FV6+dx0aTWtMDa8X3l2bZvBfgjlvW3SEWSmmkTmdbDsZfGnIWV5jlEqsow+I52F7/wBTJ7SpUqVPtSpUqF4FiPXJ6hD/AED/AMm2PljnJ4ICWleW2UZod0gN2fMtUKPlfEYIH5m4CtOYgyzziAWI92IaItVhTrcMlkfiVpCGs38yqBWl8bv9TTam49u0z2cP5heQIO8FlBSn5xCI1kJ6OF/UFVF35bjiDuSBYnvBmsIBeKGXywZgIKrIwLzxLC/AFZPrMCXdVQ8p8RBbYWVY2N4pw/MByoq6BHD2S7HSS8Q5YZQukpIBzljRJG0f9HEQuQcjQvNaByhmUob4VxKBE7moM6Bs7osTl8uJZoSDqjV3qk6MIq3A4q4oGLPd1gLcXYLHg3bfs43EkDCGH+6RA1rwGu97+YHdBltfslMGyjI2/MIXQaoRB3LYaRL5VYPDAXMbC4owZKviFrZ4jDhOLVBo6tJ/cckgYjnkLC8/mWgkNAp+pbUl4Vb9SvRUwRgeipUNDAzuXW0VsmUNecw8OPL/AFP+MhXP0fVzki9Vv+iAqb7b+WIkDlaYQquBQX2iNg30vU65UNRK3TFbtCntFVGQvwR2IztEU0uR/ErGotfseDibwrauKyx44TarNbh3iilDE8hjHsfMDDS8Q4pLHi8x6fPE25FT5haYVzRhX5iiEQLkGDjnEIcSg71oezwxyBA2ZA3iV5GMmj37MIXkqA9S9sG2w37KdFxHBeRbomKdfiXYE0A32Gq618MHCwZQu18Pc2SyEc0UF61d+YkWqGLAOQHhiC72nIOx3bTwyuMZDmx4uZNB1a7pyPWGocEa+wjAPNbXtKpgtZVV1jjkwKOvTBUMgpoAAeNR+FsLyOiEt5RYpqr4mKdMVi1HopnKx6alQiOl0cYgMtU4zf1BBV9AyeYgSmCkDHah8ha+8xxK1wR80mhJUqB6leoLZaOsBerDg3rSS5l+iBUGlYtahrV38Nwjd8nxLispy8RXtXF49hATEdpzOvxg1GsoBtrBF6tdQ346QwChfN5/6j9XRdA/2o4UsVvqTH5lVBdgTvv5JWrDgB6lJKhkLzA0gsp6Hr3i4N0HTrLXa/mUzUwnNNYxxjEDl1BlVbVr6RjtttilUOEYJmLK7Cyn25iIAHmzirPEMQgjawxSm8dfMSgywol6z+El/fNw1RyMCdmJnRjZ3tU56QBpXDVoaOj8QxweysCoZsu3tFNqRfCbGtnfZOJdqS3N9tJGipKMwbl5z6OtTMvcU57sTrcMVSznjJNzQYdd6jjtqHAw5XJ4H7gAHTFpGMDq4Vdp3lZQqoZOqDnzLdIclDFCalMg1lcDXfrDNBhoWeGaDEyoy7IxNKtjjfZGMwuuqp2eYBJ7XErS8COyXBt3TWphENaKIboQ2hC4KBq9mVAhFSpUqVNMQchvoMMKWeVm6OulE3AvtX9wHC9t3M5Sr3qYA6CBA9rp/cXoj532usbLicvHeEGXVcAO0qGZeuoewDV+rnEZTgFRuBIswcAOZloJp8Zv3Z06P1v/AJKo63fgCfELGrVQYvp30igsqinC/qGsKik6psSH1gD3KTwwudVYG3DPc3EyCALwtq9gxC1lKAcdUOsmSFvY2KN1ZpvPPiAACiKtC7yTLZRt92avp+4d/qoBqvYxMqIFRRL5rcJqBSr2eCVmU3LEMWAk9wxKah7INHzAtrHCxR/HCKpb0oNpzU6dYpI4IWB4HU5mKwHolW5B/wAwKILomT9iTWW6P7kdhCjlQCrPkesd6oOpkcdIlfmBYJLtDXkl7uKFNc2JW431EbvteZlh7ZbfFyo17wTD2Ygbqp5fZJjbo2Vb7uoYD15C6hDaZc/tC7RFtlW8sNjKr9XSGbd1V32KgS02+SVAiSoEqBASNu4eCBlpui1+ZSNN9XicpSm7il1dXAfMG6LeyvmLXCSIUWfn5YRQ9l9IOahn/qMMLrF8EJDaGXv2IjVGLTi0lxF3caOv9TGc6r65hCqK2cY6HVhjBYNBRaWeYc9oO2f8wA8nJ0zFFsS4Haq8YtguywX7wWd4UOF17AtfiYQopyIo2f7ccmqqGAoA+CBHOXzsfrEMyaWAqFLvll0mvI6Viz8wWw1blTfJj6Y9QYYmn+4tRaxpqj+5c6WgoMqz7RiOWosjftiUDAIbtqlUdaeGOKbKuCPQOu0LZvHHPk6yq0tJxbSsnZ6mY8U3F68ciZxfJjmGqAabItca35lBOvFbk27a2RjCyvYyHc4SWIAv/DP5gJMo8Ed2sRts8wmHACxfuDS+5C+cs3U5zv5lKh1T9ImjtVUG+lwrQCNKbTvxDZ4asWV7bl5JS3aeOYSRttYe+AiuDyRoHaM2rTuHiXMrzdyvQJUqVAjUu8MtNV5iYYM8SzLtM0QewHTcVDdc2qGLPkGj4h+HbLrwOsEobVA/5AYwbUtVFYWAZQox+Y7QY5/7LB1ir/qIwZSg6EFAtZny/wCy12Rsw0/i47ErXpg39ys23YrpfS/MKabdOpzz02xqCt2vLo8Smjuu+g/KuWXpBKeUB8wKKsArnOce8dwtlO39BCA3oFayb94+1tKCbBDDCkypWy6ePi/iHMV13pLTuMvBbl1eL+5YQhWzlde5Lwb0BikfbcaOiyDrZXMbkRQriu97I1JAWeRyL2HbURRtkGwxSOV7ys1OuYNZWZ0kdlOQsvMjNdy4JwVIbDU5xj2mC1YUnNq2ulx+GwEwnPe4YqtA1p76PHeIQ3IuC5L1iVCswNiwHPd3O8UIWsQkAnA4faKAZZxk+dxqNDL7xjmVqac8P3HgwuEiofQW7AfRLlBNApXswKX1CJ9xJdrtC/LiF0BUOGoUu0ayfqBAlSvQjOZzDC+38s3OSCdXlEWUFvvJ+MypxdgHywngHgvwG5WzWg5HmteCIU7cWLXsBHh1MjwvmLpXola4CMEGM54lh05ex/2aCVVvTtGXZX/TMtABy88xgHQD0FvXcjYdWOtBvzvUPWpKvUy+RlLblVdhhR3plPVsjAVgffcvKUNhusjxiUDzsHkYfmbICENVURzBQ73j3EtqsNjybJQ1yxss3z5uXfEpgvPK7nbiWBF74gaFionR7Qr4z2XyEy4I2rC+zXTrKMrng8j1MwVVKAbKwPToeSK5oE2JeTvgcTdOaGw3s7dpQnrXR1DzdMdvJpKHm+lm4UJmUBksekqAJgBkxoe3TpBHgmnwlhq+f3LtrDfkDQXZfWPwRuiZB0ubnXkcP6D8wwAvgUYGWAWBhOj1ISxNkWFt/wBEfajsLCc6RAYeQwRoR1PxE5jRd18xxq+H9iKb9HWr94+BAG26etzvfbCV6XCMuXLuM37mNmC8Y+5sgdaW4146vzB7crV8w0Le7Af3A5FQZpQeI0OA4sv/AOzNUju56HfpHksPDQ8VFlaChz4BxCCiG3x/UZADtXAGriNlpXsc296hvspRevMCvQ21hTqKVR8qZae2orhxg9VwQCSmxrIK5vsfmPFkj92ZnuWroAAd2rlILQXtu2O8Jib2EqxS/pl6qtidtJ5G4EYlFo8CU/iI8ZFHw6rtAel2pHn/AJYtXEt5prF66GZxCrOLHT2U30SaHGnSZw/pisgkU2s+1lvZiGD3w6fc56JcvbKLW456SZp6RvEoSy5w5rYfEbRWpN5GC7xjO+ZZ14LN1ryHD7MbGiwV3/2olLV4Lt3rj6jHMuXGyxZwwmBCLEN6DxcT0LkljfS7oh0RDCjnjyGICXAvPh6xKI0V9j51GprIJTXU7RNTOMg8TK1QWMj3mW0KOcd0jzKdG7wwwCzTr8Q3UQYLshCkrIWfMrNm8EPoDVj/AKShKp6OJcuXBiy54TRNRHAXxDVTJ1zCF48f8jKy0azn5/qGxkDm2g+MzNPG18OkVtQDg7fqLAOZR7FvyxttbeQOxys2ifSnyX4NRAGJ+UNc9IZ5wCgXli3p2IBrpyXPlmNiLcbdKHa4gbIvYGQ97mZRQfTR78y7txRc5VDXUCyNHuZ5BarymjvBDWKzABi+/MsSwItcuav2ma8CjWirX5ggVjRTtRqArACy3R/ntLgVTy5YBgOgEdtp7THD0joxIgaOe9e8QVaJhN1e57x3ZQllWd3WZRyzyPgi6cJxBCVsOQui7vS+0NAYA5z4TsP0xdr7JHYMezxKmKDYsWHSIF9VmLpu8/MRFNaeAOF/DBazstlp464ihFqkBnWEHT8ReoDuwwvR3JVtJlY1HR/PSDs2FKsbHMRmxNH2tpa8lwoxoppf/kSoHA1hbH5ljXYxqwv6uogBhlgoY22M9pd2C0p+kl5zDOUvwyyL+x+YdisOBv5OIZWlfa/MZCjjiXsQBeva2+IZDeGiXLly/UE5gL5O+YqcHYjCF7X+YqtSm9E5Rd8fA3HLEaAo8Bz5lyoFkVerIUPuxpTml58BV+DExPWVwp4Ne8XtmCFK61+2Xi8rgzV8eYJb11oHY6sGBYYa+4ukeWwAuQy9hy8xrSso6ybU7sZjadSlz5ojPIYJeF++ixBrGOkDA1DdNgTbaNqwAKts26Dn7igROBKu1B9+JmYS88IOj9Tn4B75GFlkI/wfa5XzBU7WkLDsGBrJrxVQ1kMM6KCuSr8yocMxV1A/2NwTuskcA9nWnJ0uP6xLQ7Gaeee5EtC8nmD1xh7QGBA7SVZ4NJyTSkqp0enXo6S6JQ2XmrjhczaK/n+4HZk0sOvSXJBbYL4Oz0lOSCwZtNLVPR5j9DoFwRwJf7ydZmrQC4wpD89YkxzKYBoR1Z1gTfYMlh3nFPSEeTklTk9ptArOh2jtThstyHS473ZExhKej5lDbQ71DaPFBwLquHqQcYAty/JslpV1/JUxLWc6EvbV914jiCGBa+dxnoFy90sQiAXdtMACUG/Qv+YAy6t6cRBWpxo+o4gU68e0W7k9XiWVILtw+Dma/Ol+DS+7KxcjehOBRgQbZqlt75fcx3itEl7AVxfL0DBAxUdv4H9xALT4Xt0uKyDMtUBkI5LoCoOz45jBNgFTegCbzpscW/pCYwUO7IroYivMmkODr/iAqLIHiw6ec+0TssY5QYAIiXY0t1X6l8pYymGkfxFrVjVX1njcQgYvKteTQ+IgK1Qb2U84WNBVjDoUeLBjyLtzJRzcXZUB1CXbHz620zEdKNLsHm3xMZbADq456/mDiGqso6ldK+oCktLznqHc56wStIJrT930lZOrbzh87hQ3Y62JEgJCqKodUuHolIVWlWU8NvsYJRVReW2GgejTKpdWZmFlP6RWWrUNAdK0+IbgaEvCLa5ioRrAYB1eYhULBtg6f7lNvjAa8pfL5yNWcrvKSORw4c/EXaUGMgRhw0tpunqpezoeT3lt95oh0bDDv7IAkpkFofMdUTpAN/uOk5eawfMqObG6vzG914zl+o/xA5qdYqQYyCvthGgtg492WdRng1Livc4Hvz7TW86n0csVIhSprXnARy1egobKtx5+oqCONc7gDYdddJbIK3Fi+t8Er2HRlHnumFzpNBy6t6+YU3RXbyV2XHeNoF7U7Ce3Mc97bdo3j5l0dtjuwe4KwKzTLHVNO2URTP0Mj6vzm7gFK6lghy7agLsVF5oHHwGIPNpPQS4vwxyvtqMNIFN4Vx+ZuLWKwFETxmW6nljs9ymFWks11qkfiPSwlDV56wEXbDpZrJ1GNqFK2aKcJD3Bubl79mOcEig8prPPaPaFFpha6usG2lNWUPReHzhghaR5GHk6jBQB6UReOcPxDC1diYSnqOElcEXw9H/4hI9ehp7APzFSBLXhOEta+SFBlgSKrCvxHEXhtRsAIGdH7RnByF0xGrkVnApz5jAWC+xyqGKLbNOsqCaLv7s8xQ2AvcdmElW1Mr7R8LWic/NSsiSmhfSEVYbq2GWpDyr6SrSl75fcYMHj1Lj6FOYcjAPJ5amPym37iBlV6vErxHYOviD4Cbp+2VKFcP7gNQ1gH4DiCKw8y9ja92HooJeAe047cx7NDojp4+CGXcFxQnOoDq9oCtb3jKvPB1ZeBqDcE/R0hyMAh1nR+2ACOguKXb1wQsAuNl9nS5ZeFToMg/UNBuBkXH8XRLMI/J1fA6xoBzWeXmE3di7T9qIRwprfc2/EarePsLmNBFlnlCfglPLlw5MP2Mulva9dPshY0XAc5v7IjkSBWM8ezMZGsTjTPnr1gUqpW6zThs5Osz0MxtT3LhjaBTlW4Q5rTHuxicx6OzTxeI9qX1go9HJ1uU1Tpyds4hW2eUpHyUn4lCJ2L2J3xf5jMgyzeR7jxHJVt1kp3JUPsoCvNvUdTZNqQW2cZOGE2CqMQBp61+JXUJpLMt6cZqL5x0iA9IpRWtl2lYsZVhChxHWY+qDtVZ3XhghG3Q13rpAWqV0KR7nJAzGA/NFbajNOU7zkQCLkdyNm4s02dSJUYpodlwRL40LZCtIvcV6F/iFy/RUFq+NmBCuzq9ViNC+SXR6hVsCpZ52feteIvlXbmJIrRoqjslZEb3z+22bTmUuh3/pKlo6Oqrr2IV9XkafHbvMkqt4FDnwwETFWGc5UJkKqWG0XV9zXiIB3xczQYNUfBDgXzbE0V1Xb2l3OEOhd29tsrf3G6cAdgz3gV9XGHgPY+4ASxtbrD/cFG3rpRZ7MAqKqd018w1rJEeLH9xVCnVXMMPjrDBSmkc3XD3KruSj0KHKYTqYe0rqSwtwBj8EAM3X1oYbORrMBvY7XYtPXvhijnS2CGM/9jY1F2revQ9estoGGlHTBadesUSy7TJXInJFM8yTAOj1gFbBAUFj0Rw/6pQoBYWRJmg5/SXUWpR2OjwLj8xM2ext5YeTmMaEqwAjw1dSqFuXrSKTyl2iGkWHrpV/cUDaoNu2695Vm0raZ6OGVFfEUrboO67MYcLsx9XLAtejWdfc24C0ba94RyL169yAgSXTevmPal8AcifVM3VpS6f8AsFI5KstE6QoFFOKTz/cxgB3WRLQV3i/zAp6QLuCLA2rb7wCBPtle/wDUSlHrh9o6e0xBWVjSvROVBbHxb/MPoE6Xf5gtRVdrlpUB8F/uNUF6G/LtF0JDG33VuMjpDN1q3olIFVdOsnu7wQtsSzagG3Gg4iKILZyja3xxLYqt2HQErS76G0HPdaAmbLwQ758AISP0jbX6xLGLcAgKHtcOIwt4C1fEXytA1t/VQcikCOx/cUTQ0TlT81jFK1kK5T8/MEQS/csFdMwoqBWW7Fc2fnMehRXbVnc113MtXSqyU8PaWKxWM760vbj6lqZ/LmuE/UDKGw5Kd9H24lnNbD9HDGAsM4LDrT+RuCJUuKQVmqdkHPQNdRwmLqbLWlUsOF1fRwxKIgsY9MZBxwkNNc3TPZHDcPIOsWuWC+ZdKNQ2yvk+lMZVjVcG90nXEBhANK28o4lKKtWFPbP1LlSCrP8AI/UNYLd8leNQXpAY1x7uvWX0qXnWejBkF1/BJqhLGw+0YLCo0YUMS3sLdu0ZRTeFKPebFpzpXzFKndAJK/wF5eXlpeOCa6sGs/ceAIuDFgpuvaFsnxqnzE3k8P8AcE7PIMqwPcH+Yvdb5y/dxRX1h9y+mmbgBly5g4mmVM+EDBrM8Kti1YEqMV33L5jhwyHUBw9C2GrgoYo6LOrHzyrF5bFfqVO8RosqgPP4IKBawdDR9w3Nq6ZsOvdfqbnFPsBXvDtfgrXj2qFMsUc6aWz7jcbqK0rgXs1XmYgWdW9mB94FEAGLQcj+GIqGyubqEYMdnvXPxL01Gejt+wnDAKHA4TszKNAuvzKChJ5KdO3Z1G4unJSnOzZBiQWUevjJccWFAI2V/wBbhhCicBU6g3457y6OcFGTg/sdSuvAFaEaHp1EjVQ2gw4B15uFQsSNjOckrCAbDodnlhms5TQOipqW0KC6RpOo9YpWK1gHtDI2C01T7010gxcOaKvzASPd8Z6wjIb3cyNhRuZ6wiC7DgOThJU2DCZT0iIEE7nmOsKigNHcYmnWMZalapnO34/8CIOi92MW+8t+iBZzqieKMvQjoSfgYq7E6BfuoqVReASPgPhuMzf6md+bh4Bj9sWm4HQ8/olqCsCBfFtjc07qEMIcBFxNl+uuA69IS+gVanqwMAwBSLtbuFKgE4oU7XUq0Kl8iar/AHEKtbVi9DUwpxF7CrlAJmt7ofSYTd8ORRf3GjzQV8bT9y0VqFo6mnhhCEUPZv8A7HeIdcg4O9al5Cwt8J3/AH0htZab7p+yLkzbnC3hrhlA2eTnudn6lFLcrwOSnk5JRlgc5Hyc0d9RJSq0dhYbO5qIEC0GRTQSZ0wNts1rjoMKLoxyDs7P3C3DS2opiaXIUriPJx7JgV1AoD2K3KONWFdnUtj2GEBtiqodTkgmvLA1xrp1qERqqCwX2PaGUsvDLbemMitFmxOzLA2jRmuL4YotLidj+yPii6zsgefqcwqrMBy5XeNtJZ1Oe0HLLmm6e50hk7pdDxxEFCGbEPibFJ6l/wDkxY14hjD5Jg6i27YyLbWW36IA1PeVy56tn4lM+3LvzU2h1Afie/R3gXhVxn4lvUAbAO9WvtKrzEcALigIqpsYLOXPmbwqG3F51ncGiijBVL+XyRGQBYNKrJ/EdSFqebp1+LiOFRUdKYeajyjQzzVf1KmUqrOafyP1OQg2eB/Up9t3Rp8EdR6qqw6VmvNccymyhTmoPoMLwsAHe8J3l8CF2q6BqyVc4lHfuO34xBUNbYKJdZRwMjEtqg5e66dHiAEOu/Dw/wD2WWVRHR2f3KusO8IcVi/bMSpdhlChfKv1FxZpkOKvIG6ejDiKeoWHgR4YUhqhVqNHZDNGVbBvkMiX0jMyihUE4AcxkGBYwl9sxC0W6TSPc6RaN0gYrlT/AFwDHYKha7/kYE0hSmw8RhvNXjsxKUdR0kJUD2tIZqsvJz7Q7Sdgr+oHdN4TSdoOiuC8/wCJZlJuzXmuILeEYQYx0lsIDrr4gBkdVh/8kOA+alrX0n4YXyb1IafPG1PzAbUex/cFBrYF/rBMIHsh5SJha+Aqg6q1CuhPvvp1iyq3XF9m8EwR8038wThTYglZu3zOJBk2uiu7xGWEpSNAIpctpb2ODsnd1LdEBWQS1HjXmUFLhlN7av7YOl4mtdR8xqOFzqUD8k0PA6AwPKMu5AkboUeRio95muXZT7k3LzR4VY/3Am4RiAij6xUcvXUGl1U9ki63BQw0yPXRZplQJHgauFd0+yEymdqrJv8A4isKNB2CXqtZxcenQPJvAby50IGliE4DudSIA1IrHpf9wwooXAHrWmNRFuC6nk6VDaHBWFPyH5iIpCq18neOsOixMlaMJYRmacjfM8UDojcaBAqgpfYfeMlIHAIkrLjVLCcWZHzLcJWcX4Wi/eHXVACw9+kysStjIOjKQa7CldkgvhjkPZjZZBlMnZ8Rbls5bK8xXC22mViIaHpmdurTL0BMma9orKVWhp7VNRxSI0Lfk/8AQWJk9lqVVi+bg1g+5H0puKB4057TJTmxyO63/EfiB2hf61EIm74B9YyrAUMBbeu0zIbLyaNFv6JWNslHTCrO/SNK7CnStX1qDWXbBnQo61pdRKl+pc5/qK6phfJeILR+qFnXHEWAVQOpkF+SX+r3qqVzF5gKTk8+/MQaBffZPqNNYoiWItr4zB7ClDkODrs+JQrbBgg0/i4jKZitI4a7Msw22EugyPkK+IBaBQM9CzmvkhNUG7KHYF2dIpTZVaRNIOg+zCAFmBKaM66nErOItppV1Or4HEeIzy+l5oXHs7mId4uI7Xh8biHSOB3VmqZz3mBErSS61i/IxCS2L61kUDD3g6q+QN9BHHZiuvAAa6wNIYFjR3aYlS1YOatvhGPCFILLgb2SlRtmQIYoVqHpTa4eaOIhCFPUe8ScXTn8d49ZKvYPZgGjNGm9jM+lVk48wbgkzWajW8pTS2vtCUgUqs/9mGB2tVrdJBPOyVT/AMwt3BuvkgCIzxI6FXff2ygHekXHu29gYPUeWGeaBr8ythd5UbeBmn0qlB8FESwzTf8Am4T7gYfBzBgAM0Hv1exKJp2rQDwhaLLpaAFrFQKTT08xqAoF1yQfQAEGaZng2RpYZWQOK+SsIFXJXnrAkqFZXHvGkhnOq6/cfnAIOhBr5neUbhHT+pQOWoO+x1LilLXT2U7PSaDM0/kH9Q2gDdml5x5lvTkYwjTUCGcZ8Ncd1aXZzFbwEtuKdOjxBC4OE7TjuTr8yvQdMR5S/liKfTZiT2tp65jgN2MTslj+YyKfuTtfTvmFgUvLR5GrPEHSHM/C6MAj9agt1houYEm5vwbWAoK2SFvD+FI20KlTDVowOzKlHyKQPRGyHBbLKU7nUgCMVTZ+9MSoQ4DD4ioBA2XqGAFcoVKGFXeTt3uLqXTRprqQDKpxSkeiQyFE6mqlTreSwPs8xdLByIAn/nct6wKwq5vBWIQIwoSKHa34ldg9Cj9gR/R1uh9f2jKtorSB41NCN4sNvQgqBqyXo6Y0RB11Ry8TMhA0C0/3MzUBrsCoPKBLxiYY30mez0+IzWlxYy3d39S2N81dOfYh1Ui3m0uoVCC/F6mW4D4WF/cWFpldXVJ4cQBVMBMlgQe4zOUqR7D/APZRWIiGDqPaCiUPHaboRyd4ZW513vlcwkhawcHT/Iw91ussOOMcPuKqltiLdaYzyRhkNQbc6vadGXAraCi26u8H1BaSi2d8bvUoFDyCO74vkhAj2qV8P+8R0umoJRXRATxFY8mqU6jjPeGg02VLdQ+ncpLXUUM96lifoH/0FcMUbQUsAhwqVIWcnG+jkhoGoCtEPkPSLEFmx2p0w/MUCDeOe3eY5KZDYP6lcwRz1JSNmd1L0A0nUSYeWMno7uUQPZvfSFC1B1bT0Yo2Ow9XtGuaf+nMHD8kFjTx/SBEVV6rEsu7uCLR5BzL0ot1QC9+sRrgNpwef1BIfPXbqesS0HR1fF/mO3W6DpE+oKHd3B4UZM+zHmXiEC6+Li52Iq+NH5i2ADgfBKyysU61/wAqAuePAuj8xRsH5l59yMQCFzpCzqIw4jBm3ez5sgY0G/cg+Rg+Cu46c+HDDrG4rw66oK9Fjgely93OjT/xgFRxjo5Ds7pV8Vrer9p06iDT4lRRWMuWzm49KiU2C8nDfaISrSdf2/1TPwKNVPbo9TULDJ2gfHDEdgeq6+oVc3TlWKnKdzJuubah1hWvJiXUFEaGa8rKLsjjHHCXkmstIiw+F0wpEV0Wrxb9Q5UpAX8qmCxLMX1H4Zm8Tlp2ZxGlAXHDMlQWKHPZhoOAcnbtLFIlg7S6dS+owycjgbzA1WGlbaOsIRusASHsx3i4aKPl/wDQg6pRr4Q1Ste9rHoU74iy6lWO7xtOEs5tPF3PuURTEdI4bUq714jUrLs5vyyxVK4x+CDfRSDgF5Zn9XlotpgL9iNZewvjJ0mTFAA5QmDHMa+jRHKv5rljKKUE4Njw7Ja7a+evtETVGK2tq3eobM5Ler1hwLojfC9orRseDWIwvW403qvaUoVhTgOS+5eO0CBaNd40neCDBAvsSnDXJEjSntrDuVKUTJqfvpP4Y/kfLYDAl7QwkAo6YNQe7cEG+Ckoc4vXc1HqTBBV54E+oLqiwo8VJ0fME2EZcCYpukez7MG2PQDwmsfEegmRVg6w4r/YmaKFLV4/2YzioNEKHlj9qOmvkaZnjlChfUy1EGnKyUPU/WoVr6HF1xGSi+ayvEQTNMYGOtaY17lylNdklxecDSoKxVim9J1li9BrKj1IiyY4BRcZy2mZwIMHYnWHidwpOpcJK7VV/wCwHFwNYo7KlICvf8mEKN9Wj3UurXMbc9FrzCUwbUz3SwG+6xa336StNV3/AFMk2DV8cHbqwpA1YIq7rLHFk6G29Ep8AgDVLHyMqSWaVeF/DtFMeG4xaPxEIy1i0c8ooDYXhX9srION9qZVuwaNVSAutoBruP5IVQBtvRX5ZjuMaVOjR7Yj2M6uhy8zK8T7N0wLfIwvfOzhOkvO6WNUjVHh0pzKKKjGj5RM4zlW3TU4YPQAz0my0/Rg2dwuSt0nR030i6w4gwE5ze4yutnIhMFFg1y4ZRdULzxcicQ6dJcnt0DxuCFNo07V8zADU7Y/5EN00pVduJU3EbsK7icR6rZD6DqGAjYRNvQOH8zdMJFvJKQXHtB8ibqWM7NfC4FQOOt3FxE9V+opVWxTZ4qV4Xt4YzCvDj4j4XgDxApRRdnECeyw4f8A2A5Ytye5j4mDI64fbEIByaGB4CLSsHYgNmPTLT8CZ3uhXbtV6H5gq7MR77u35Q+QXo9n6iXGASuV2HfJGDZoOr/7KBCzu3p4fcQc7fLHPbcrVfIi2zg7pAkbBKzkGvEpAcYqrW6e0pMIZK9vhuMqo93UFHZu4Us4B2cmYQ6K/cGXLC9nDy0y7NuSN2W/MqlBQ7OfpLVLG79yeYQWrvRVw/dQTAgsoias9TUcbN1472eR6MZGFbNKaxfaYB0Unj/alEEYKvT79YtgIbHEDBauwFK8JqJuBcILwweW5d6ahLPGdPZiYE2up4Uv7MTMcCLnEbhLAq7Ao2e8cqFDqzeezxHT9sXZHNO1Gp2gYHo9L4lrBZ0V3GPDYeVzMVhqw4ZUq8OesQgSjrkh0LyMlae0JLKBs4TzGm+wI5DfWVeGZEI2dN5BZfU/9xdagTtT4JjFHU59oUdXpWXvEUdqXv0IzgooOjm3zFABzY76vh96lI19W93MHkoMJtGL8QtsqA30ngDc2IR1XKq4NRkrI5avNezBJAsB6YkIxNAeLK+ZZVLW++iKoLQKzQ4GOBwAz1u5sMgm7bh+yCKxZV7Fw/MVXtqIGgW69pvRaU4WG/EWWEvYD5RNVzEoGbmOZDoOfEyjY0btdhk6mItULZ7Ed44/UoXMbLUGrK/URVXBCHYRq/E4lRSYQ8CFdukKpPSfepVNoMDo7OkiuBRSBReXNS1iRzjTzxCdIvQNdRZO5B9LnN2C1+zL29vCatzTMyctgKHGS6Yevhlj5cS3w3NgnUswsQGg0YYhVvWkUSG7ABLC++MxqDoQw+UVhc1kNxzQb08R4mTDiHWPZ69FhZHSM1/UxYNwzmkBpYcXV/8Auc1qAJSHdmyb+wveGqGLHZd2+vxDAZDg3/yURgH+vMTKrIPY7Lg224itPwcJhFSe22h+4Ramziqp8+DqspjMZM6DqtI3bKUm1H/Yh4BK45u9+ooEgx4FfEvIKJ8coJEWAHo2kom0auwn0ZWDwvDVAe6xyjf8gHyVGTOAVzqx/M0ldNtWlj4Zlwulu8YzKLjRAvjgTp0ZS8NKLvn5OYeENQtPUH/ZgvQECwPNfqLQc7T/AOA7OpslcFGeTaHbJKSF5p6nU2D8ShSyNYU9f9TAtKrSveLsmEB26XiJpAhVlOe5feocrEZLm9ainATBf9xDdSmwPeuZR0GQLq9ifxMijeqlvH9RggVQFAj31GINOc5TrUCIRLs4f+TCA/8AMytAvtzFgqXohhaeFj2ZjNAMO0XZMU666XyRTd5KvLvKZ6Ycn/tc0BdQsL8OIAryTgOXxDvCLv8AwujiCUXRafuHKAatk7+9cxOlCwd97tMN7VGgcPd0PeNrmtFZdX/sQOSLwWW7dJamBrTlwrwcxAIlF9W8naWNigvA/RLIFUdFAfliOqoqucDMDF2U9B9Er20KnLp+EJvaTo6rcdAEy7sHB7mZoeGryVBsbFuuFPiYqYs1+YjIWO+44YYoVRJitB+GY8GhrC9+9xLggV4xw94UECzeHyTGokJrHVH+6xwMh0D06HeYFCNmh2rk7QaXKXlg+XMGihalCzsIi1Ij/PmW4LMquzuYiBeti2wdE/CWMItOXSmVKOHcWcPMGDS2H6OHiKa2Mo2L0f1FVB6hvz3liXKg34j7LueeyQCFgRs7MRaydGL7w11UMjcNoFmcbmHC3a58OeJhAW6Sqk4GWuRsYpX/AL2wlZbFrQ5imV6pl94cdXWjg6vVmG7RQGh/tsP20Zo1/TzEei3VL1892FwGrXK9XYPmEorhbd9B4lwcwrtx4lGOA92ncuLisBY5f6aIa4HeAVPfLEMtvHPkXu6l8wgMsCTK9ovTBRo1hrdOgxyFgbcro8sQOwGLu/gMvqCGg9qxKsdrgf66wliqB6WwUwWJUjhyvpxE6lCg6JDZS1y+C/JDshXqbrS/3F2ZkIeR+5Z4DbRBcpyvEISyzJBvfv5MxAoWjnwf0zwiqyvIe53iy6F4aB2g2bGkRcaslEJcaB7dD5jFgR0og9GGITxsvr5hTUoFkUTzsi/LbTp99R+Es7U7M4Qjikb7SslYWLLz1grrUtnUNFpzsYQhRrT26RxVK2s3yDCs67/NjhJc1Ll8o6neU7WO5R/+EZUy6NDs5l+Utzyf6m9Zev5mF0aGT6+WM0WCd6wjscQxAHLuzACbWf4ZlOF4Hp0IQSGItIo+Lz4jfrKt0Uv9RorLac1/dcd4h42Y6Dj3gNSCgW4GMHSM2tLpy3x2lixlo6LlfMQaBA85H6geo2P2z85gKKuw8A/uOnqrHlDSUoLwZr4agKoEDmExftr4gBjQi1Z0H/ZlwbUKtK7+YXOHB8Kck39HLHwyHRjJHujbuQWHQAlK/T4bJTyaYNu4mGoCr4CwPtn4ROtsbAuNYgG0DSc28NxddZV4qxrmyOTTVSiujWmZpOEKvs1Muc1BbEBfpkuQ9K2S9NQuO89meRGRfZ1LQttleRivGmUN+QjsDJZnK7wBYRpR0cjGGtVjD5sgptUU9CWxF8hS464//HcTrHxv8PMEXditXkOZrqJ4eozWABNLo9oPrbK4PHMULeo8sLh1Y7tCsR2GDBXHf24hmC92Tu/1MFWRb2uAC4oZv4O8DNA8t11XxAudS06aEVQbtfdywx4oqju0fqAqLa/ei/qMlOUe1lMNtbDPCLPxLh9URur8xFJCkHJnI/uGyg6LydR4+oquJUZKrZXPj6iqUo5QHC6Rieh3SpXWjCgRZ0/I7IjvDsr5nR7woHF1qj5rcuEC0NrychjsmACqPcdkCVK9FW8azZLY3YWD0dUWyEZGmFseioK+NQxwqogPnMylEMuCPjvLdFTFh7xm4ep4ZUWRhXD2YgB9A+HrEugYqck4ZXVN+RMpDNtG+nxFmCcOyu3b/wDEahNjzPqPR/tH7n+J1T6n6T/H2n+rsz/Lz6Nv6d1/wxPop99H+DxP9zqn0n6m/wDtl6Ra/H9zX/u2f7Hef6PWfS/CH5T8LNP85n3P1NvbPrT778T8Gfk/qbPOfmfSfSn4/Sf6O808PQ/1M//EADMRAAICAQMCBAUDAwQDAAAAAAABAhEhAxIxQVEgMGFxBBAiMoETQJEUQvBSobHBI1DR/9oACAECAQE/AP39/wDoL/d38q+ef268NeC/2tftLX7BfJD8FeRJ0rs/qK/tZp6sZrD82/2OtcpbehsRJT05KcenKNPUjOCkuv7Wn5EvvZVolGjQk9LUp/bJ/wAPzK8m15EvuZaodMnBOLR8Lq2tr5X/AB+zryZ889RDrqWiX0yUl0IyTSa6/s78b4E7sjwSVDk/Q5Ph9TbJwf4L+V+dfk6jqDNNlUxp1hji74Hd8NE4W7ITbXqfqPqKeTebmRlnJfjbSJ/FwTpZ9h/FP/QzT1Yy9+3k63213ZDbF1eSSTQmInNUbpNUJNMr+RXyPFYGqRfLIzFNPwNpK2S+Lt1BX69CSnL7pfgjCC4GQxqR9XXk6/QcW2aU7jTGsknRzRRGhMbZlrkch8IdDw2Q1muRaqZqfExX25Y1qan3PHYUElgoUUSZBXOK/Pk/EcoSyQSSslIi0+pfAsst9DhC9R1WCVVQovI3ZNdhuuFk2Slz/AoRjhKyTj1E0JWPalkdNmhHr/Hk66uhqnk3OjLKFF0ehVNE8yHhUXkUlkhKpEpJt0PLHHFkZI22OKXRm1WVSJWyEbdCVLyGzUmPOSxcF4ISqKIvJN/V6ElUiLvqNux0sltOxMUmcnUiyVMuhyvga6s+HVty8l8GrdEYN4JwpIXq0UrOERlSfuNcEpN5GxdWKLkyTVUjbkUaXysTG85GmxbUjVabpGjGoLyWS5sclGN1ljblyaW2MG2Re7sT0nVr+DbkyjqakvqRF3Q5VwRVyHyKXfCE08lCGierSpZFq6ilbY4uU1XUSpJeS1aNuTUvJDKPi9Rw0YV3yfDyi+OKJSSRKnkxVFo23ISpEmQdKxZtskQVCZjgTXBtVsemvyaMP7vKYzLwbXH2NXSU9NweLyn6kPiNb4Z1OPHXof1etqyVIpx00nz1G7bGJ5QsklZGEuzNjS4GkPBY2bi1Rpae52+BKvKZqNohfJNeha4F6Mc2qSNWS2ckJ5JZG0kabVG6OnBSfLNOSkrJyjFW2aetCbruSlTa5XRiaGx2WaP2+W1gw1TKVYN0uxNZLfc3JK7smm1dimLVwOTb9zR0dkMs+K/8ul9L+qP+58F8ZGOJP0PifjIyX08HwWnJJzkq7Elgi08DjtRJ5OTRi1Hy5SwRnT5JbrtFslgeeLZKb3I1FatIlGh8Glp3G+w5/SQVUT0dKb+qFvusENDRjxp/yW3ljtsSSXqSf0ElKyCyhSRflaibRt/zJFRceSmupL2sVYxXqiek3kTUtJvbmsobg2+gvh7jaNWe1bUJvgV+xGb6GReyHRWcEvtR1IltC1JNikWvIksDgiMkiS6m1X8oohiXuf00NydE8fakiWm27eWLSpcOyLzkSS6DlXUUm+o/UTQ1CSqy0uBCbN2Bsz1ZGS8bWCSV5ybn0FLo8jQhISJPAySZddaYhcicV0sjqJS4NdvchLcxxS6iNMl8tySHK1VlPoKUvTxM1Fm/kkkbu4hNm5m5McRxQ1gjFPjB0HuvAlI3JpJotI3Nv5QbQ8rA4OxwE0Nqj6fXxM1K+VlZExMtDRlDY4ouP8jrubknk/VuOP5Gu+fmsECMm8F4yNWXRZjxPgk7YyxDE3ZYmMsclTHYkyk0rGmiNteptfb8GehVEIjdMzyhjsRfv4tWVIfA2JsimhyTFSRJpkG7olJZG84OIstMbSsg7VEWnyj6awSd+4mVnBC6M3VG6nQ7HzwWyv8AK8LNVMXBKhM3X1Eo1Y22/km+UKSbdiXORu0Ys2UJ0uCUnZuf4HbsbtepFKkR9hZGsilS4G7Gi34WydMddBplegoEuKFGiTwbnX5Es+4kl1E+fUarkU8Dk2RTYtNEmqoT6iWbIvA5V0Meo2WY558THJZTHdiFtGkNIbiuScrwdSSo3SGxLdjr0NjTFCyMUryTnykU27IxojHA4sawXg3J8sVdy74KXhbwN/UNWho30R1ESnklLBeToJZo24P0mxab69BuLeeSeoo8EpSkKNZF0EiK4HLohr6RjKXqNmfDLgmskJ1gcUyUKFwPkjC2j9LNIWlXLFCHI3A/WSwPXY7YoiE7Rhl+pBoaSY3gdPoNL1Eh+6Nz7rwtE45Hd4P1JI/VaXA52RkxarXB+s+hum2O8CXUcMlJHBuQrFgb+UWJjjaIp3lcE0rLHFG1dvFrLqSZ+o+yMvoPT9B80XfHHYwUbkKfRG90W2JMUSijHqdRpiwRYiaXYeB+5f8Al+JxsnFdrJRinkWpXCIzcnk1L3MSYtzoWeo+glhCWRIXJRaQmV6FenyVFiXqS9R+hkz3/wBvFRKA9vYk43yZrA03yaeiqz1P0o1lD0YcZI6UEaullOI7XKLi/QVU6Y2JNiVF0Y7ITLyRqzpgksDT4QstcFPs/HJYJR9BxZTQqb4G1Gr5JTb6imuHZKaUcCm+SW2Tf/A9KXYUVgSSFRaEvRja7DuuBog/ZkaZJYJYE1XBfkTXynd8mjRKt+TY1NP1OG75NJKs8DUUhuFC1Xw1gjp28M2dGNdhR/Al2TY1XQtCmu5i8ERmoL2N3+X5El6E00N31Nyihq2mb6onl8mVEi+75HtfApUqFJ8rjsRkpGxCil1KJsSMPoJRZHA6NROxKi15DNRYFFrLGm2RXJKOCUepcmkQg2xwijTjHqOMBwihzrhm6TE33Epd/wDscfUdpFvqQZJ0h8/K/XyWiURxfU2iSfJJFYOtji17m5qx60uwpSb5EmRpdBV/qI2ngUsFMc12ISfclJD54Kx1Nvt5TRJDRdOxv5yVckkhUKiKixQroOCJRXsbX6/gdV/iI7RxiOqMIdvqb/Xy5D4HyvkuWL7l7EzqIRHh+xHp7IZPl+xDlkuPwL/o/wDgupLgX2/j5f/EAC8RAAICAQMEAQMDAwUBAAAAAAABAhEhEBIxAyAwQVFhcYEEIqETMsFAQmKR8NH/2gAIAQMBAT8A7r7no+y+1ae9fXb70z4ktK1vw12V568lY1rTPYu6zPh48dmNL78+G9feliL1z2V4a7az3Z7L8FeBK2Lpr5Jwce3Hctb8K7+msWXRHbOLTJwcZNPT34WX3vSvB0/7RtkXk6sd8P8Akl/HetL8l96If2jbsWBPJ14U7+dL7loh9j0rA/F01+0atCEcpokmm1qtH/pUJUkSdMT/AAKzg6sLW5eBrSitK7K0x3xVtaXaHyJiyhPFEor4NiHHBtNo4ld9WyP6eVW8C6Efkn06H4OiluzwhtvjgTpko2tIrJSvBdjYzGlDjY0+xK2R/TvmToW2Kwhtvkomv2vw9I6e2jrQ2ywbx5EixvWyhFCHA/psh0JPnCFtjwvybvktG76kVg6rqyy+/pC4wdTqN4EuxHvTNiLWkfqUWkW5ciRY5CUmyNpZOrK34em+SL+BrJxo9OUxcCKKGsCWilpuoTb9jl9DlkY0jqypDfhhHSnpWSSHwRF/aPAo4LeCKsaoa1uyqFB2KCXJZ15cLSvBAlIg7HRbG7GuBPIkhJWP7nCFdjyXpgXwbfr+BNJUNuxNpW0TdyfijxQlbE0lg6jbaSG6FPInitEQX7WSVWV8l1pt+Bpp6MjPJ0+i5NN4R1f08FHAppdKVj58V4IVZJUyEU5y+yokmnkrNiEUbsDyxIoSE6JSvVRdim6RPrSa5JydV40KkNpkJ00/aJdGE1hi/TKOZMVNv4I4QhrA2JkpfVG7JbOStKyNuzqSryRRKiP3Gi5JEUm8ogv3fQlHSmySbY022l6G8ltP6Di0rNnH8jWNWdTxoyjJSItUY+BRbdVSIv0SibMigiU054RCG2WeH/B1Og7wLou6ZNpJRT45E7Za9mGxLB6JvxxWSrRGvZQhWQiqOm6dMtMUconKpUbckpOze/mhy9tjfxwJKhi5FSQ2S8ceTcO0+BtfArP5I9TaK/6iV4b5P6U65RLqOMlYop3Jlof0JRMDa0x7FyWMo2IcSvBF5E2NNif1E8FkmXgf6ubg0uRTf+5ti6mK4N5JDbfsoaoyVZ+5etHqjBJd6IspeyvwWNaOhGSNexZHaLwO/kcbRCqLoTekhaVkos2x+H3weNGUNGBJG340TYnkb+peRbUsmDa+bKGhDyItUWZKK7+npWjQ1pZZQpMdiv4FG1hm1KX+C/jH00SwMY0uzHgisFFa1goaEhI2u0KhyXwW0LI1X2Hgv50k0LRCGfnugrYitGxJjtsVolVCQkVbRQlwSVZGmuDNkVX2GlyhtUN3pQhFGe7ps9kRood3QljTHA1VDYkbWJ2NZIpVTKFWDj7DvTgRVnAiu6OBFo3I3C5HISElYxlcaNaN0X7Es2SyX6Y1krRI296EsJioY7MlsSbIRrImJsxpfschsv6EVRuwOTY3ktCZQkx3ZWO5EVgsizamOBGOCMclKj2WWKRaFGSWOCMW0WkW2fgb0oTyIyZ+UVjuXJFjVlibY0xIto3YN10XISZs9igjcOTY0XT0rJJaJZFZZ7F9jPdF4E0JRKVmKMDihxSG1RZeaLEmxKyiQ8lCHonkbQngotlvugxKzYiq4ExFNf8A0piQ4m1FI4Y2OReqLwPOli0vB/7juTIsUx59m1JEKMDpWPC40d3Y2Ma0rS9PXZEsdH471ISEvoWL7EpuzexdSQ5yITdZMMpjRwN9nOjPZFieB8H5XemRYmizhCtiSQ4kU7yUiNo3obZZQ1oke9JDEyI0il4IssjxwT4IrBuVUc0Sv0KxJm1XdknSL9ljZYslFaMREaP/AHHgRERVsWBRI4Ryx/RCsqxr5GmjcXohiHY86R4JZKXhizdeBNUN4E8iZhDlgTbJNlyRbZtKSGYLEUNCR6Gf9eJMsTGJll4ExJG1DpG4Y1pWiX1GiKPXlTLPRWlidibGNDs3CbEyxDst6X5Yi5FwM9aI9D9jGS/zouPyS9C5Fx2PT//Z\"\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/assets", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "assets" - ] - } - }, - "response": [] - }, - { - "name": "asset/{id}", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/assets/{{assetId}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "assets", - "{{assetId}}" - ] - } - }, - "response": [] - }, - { - "name": "asset/{id}", - "request": { - "method": "PUT", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"mediaType\": \"image/jpeg\",\r\n \"fileName\": \"cat3.jpg\",\r\n \"content\": \"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\"\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/assets/{{assetId}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "assets", - "{{assetId}}" - ] - } - }, - "response": [] - }, - { - "name": "asset/{id}", - "request": { - "method": "DELETE", - "header": [], - "url": { - "raw": "{{baseUrl}}/assets/{{assetId}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "assets", - "{{assetId}}" - ] - } - }, - "response": [] - } - ] - }, - { - "name": "credentials/schemas", - "item": [ - { - "name": "credentials/schemas", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/credentials/schemas", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "credentials", - "schemas" - ] - } - }, - "response": [] - }, - { - "name": "credentials/schemas", - "request": { - "method": "POST", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"example_name\",\r\n \"version\": \"example_version\",\r\n \"identifierType\": \"DID\",\r\n \"identifier\": \"did:sov:XUeUZauFLeBNofY3NhaZCB\",\r\n \"attributes\": [\r\n {\r\n \"name\": \"example_attribute_name1\",\r\n \"value\": \"example_attribute_value1\",\r\n \"type\": \"STRING\"\r\n }\r\n ]\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/credentials/schemas", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "credentials", - "schemas" - ] - } - }, - "response": [] - }, - { - "name": "credentials/schemas/{id}", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/credentials/schemas/{{credentialSchemaId}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "credentials", - "schemas", - "{{credentialSchemaId}}" - ] - } - }, - "response": [] - }, - { - "name": "credentials/schemas/{id}", - "request": { - "method": "PUT", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"new_name\",\r\n \"version\": \"example_version\",\r\n \"identifierType\": \"DID\",\r\n \"identifier\": \"did:sov:XUeUZauFLeBNofY3NhaZCB\",\r\n \"attributes\": [\r\n {\r\n \"name\": \"example_attribute_name1\",\r\n \"value\": \"example_attribute_value1\",\r\n \"type\": \"STRING\"\r\n }\r\n ]\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/credentials/schemas/{{credentialSchemaId}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "credentials", - "schemas", - "{{credentialSchemaId}}" - ] - } - }, - "response": [] - }, - { - "name": "credentials/schemas/{id}", - "request": { - "method": "DELETE", - "header": [], - "url": { - "raw": "{{baseUrl}}/credentials/schemas/{{credentialSchemaId}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "credentials", - "schemas", - "{{credentialSchemaId}}" - ] - } - }, - "response": [] - } - ] - }, - { - "name": "credentials/definitions", - "item": [ - { - "name": "credentials/definitions", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/credentials/definitions", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "credentials", - "definitions" - ] - } - }, - "response": [] - }, - { - "name": "credentials/definitions", - "request": { - "method": "POST", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"example_name\",\r\n \"version\": \"example_version\",\r\n \"icon\": \"{{assetId}}\",\r\n \"identifierType\": \"DID\",\r\n \"identifier\": \"did:sov:XUeUZauFLeBNofY3NhaZCB\",\r\n \"type\": \"ANONCRED\",\r\n \"credentialSchema\": \"{{credentialSchemaId}}\",\r\n \"revocation\": {\r\n \"title\": \"example_revocation_title\",\r\n \"description\": \"example_revocation_description\"\r\n }\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/credentials/definitions", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "credentials", - "definitions" - ] - } - }, - "response": [] - }, - { - "name": "credentials/definitions/{id}", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/credentials/definitions/{{credentialDefinitionId}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "credentials", - "definitions", - "{{credentialDefinitionId}}" - ] - } - }, - "response": [] - }, - { - "name": "credentials/definitions/{id}", - "request": { - "method": "PUT", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"NEW_NAME\",\r\n \"version\": \"example_version\",\r\n \"icon\": \"{{assetId}}\",\r\n \"identifierType\": \"DID\",\r\n \"identifier\": \"did:sov:XUeUZauFLeBNofY3NhaZCB\",\r\n \"type\": \"ANONCRED\",\r\n \"credentialSchema\": \"{{credentialSchemaId}}\",\r\n \"revocation\": {\r\n \"title\": \"example_revocation_title\",\r\n \"description\": \"example_revocation_description\"\r\n }\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/credentials/definitions/{{credentialDefinitionId}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "credentials", - "definitions", - "{{credentialDefinitionId}}" - ] - } - }, - "response": [] - }, - { - "name": "credentials/definitions/{id}", - "request": { - "method": "DELETE", - "header": [], - "url": { - "raw": "{{baseUrl}}/credentials/definitions/{{credentialDefinitionId}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "credentials", - "definitions", - "{{credentialDefinitionId}}" - ] - } - }, - "response": [] - } - ] - }, - { - "name": "relying-parties", - "item": [ - { - "name": "relying-parties", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/roles/relying-parties", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "roles", - "relying-parties" - ] - } - }, - "response": [] - }, - { - "name": "relying-parties", - "request": { - "method": "POST", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"example_name\",\r\n \"type\": \"ARIES\",\r\n \"credentialDefinitions\": [\"{{credentialDefinitionId}}\"],\r\n \"description\": \"example_description\",\r\n \"organization\": \"example_organization\",\r\n \"logo\": \"{{assetId}}\"\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "http://localhost:3000/roles/relying-parties", - "protocol": "http", - "host": [ - "localhost" - ], - "port": "3000", - "path": [ - "roles", - "relying-parties" - ] - } - }, - "response": [] - }, - { - "name": "relying-parties/{id}", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/roles/relying-parties/{{relyingPartyId}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "roles", - "relying-parties", - "{{relyingPartyId}}" - ] - } - }, - "response": [] - }, - { - "name": "relying-parties/{id}", - "request": { - "method": "PUT", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"NEW NAME\",\r\n \"type\": \"ARIES\",\r\n \"credentialDefinitions\": [\"{{credentialDefinitionId}}\"],\r\n \"description\": \"example_description\",\r\n \"organization\": \"example_organization\",\r\n \"logo\": \"{{assetId}}\"\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/roles/relying-parties/{{relyingPartyId}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "roles", - "relying-parties", - "{{relyingPartyId}}" - ] - } - }, - "response": [] - }, - { - "name": "relying-parties/{id}", - "request": { - "method": "DELETE", - "header": [], - "url": { - "raw": "{{relyingPartyId}}/roles/relying-parties/{{relyingPartyId}}", - "host": [ - "{{relyingPartyId}}" - ], - "path": [ - "roles", - "relying-parties", - "{{relyingPartyId}}" - ] - } - }, - "response": [] - } - ] - }, - { - "name": "issuers", - "item": [ - { - "name": "issuers", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/roles/issuers", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "roles", - "issuers" - ] - } - }, - "response": [] - }, - { - "name": "issuers", - "request": { - "method": "POST", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"example_name\",\r\n \"type\": \"ARIES\",\r\n \"credentialDefinitions\": [\"{{credentialDefinitionId}}\"],\r\n \"credentialSchemas\": [\"{{credentialSchemaId}}\"],\r\n \"description\": \"example_description\",\r\n \"organization\": \"example_organization\",\r\n \"logo\": \"{{assetId}}\"\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/roles/issuers", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "roles", - "issuers" - ] - } - }, - "response": [] - }, - { - "name": "issuers/{id}", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/roles/issuers/{{issuerId}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "roles", - "issuers", - "{{issuerId}}" - ] - } - }, - "response": [] - }, - { - "name": "issuers/{id}", - "request": { - "method": "PUT", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"new_name\",\r\n \"type\": \"ARIES\",\r\n \"credentialDefinitions\": [\"{{credentialDefinitionId}}\"],\r\n \"credentialSchemas\": [\"{{credentialSchemaId}}\"],\r\n \"description\": \"example_description\",\r\n \"organization\": \"example_organization\",\r\n \"logo\": \"{{assetId}}\"\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/roles/issuers/{{issuerId}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "roles", - "issuers", - "{{issuerId}}" - ] - } - }, - "response": [] - }, - { - "name": "issuers/{id}", - "request": { - "method": "DELETE", - "header": [], - "url": { - "raw": "http://localhost:3000/roles/issuers/{{issuerId}}", - "protocol": "http", - "host": [ - "localhost" - ], - "port": "3000", - "path": [ - "roles", - "issuers", - "{{issuerId}}" - ] - } - }, - "response": [] - } - ] - }, - { - "name": "personas", - "item": [ - { - "name": "personas", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/personas", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "personas" - ] - } - }, - "response": [] - }, - { - "name": "personas", - "request": { - "method": "POST", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"John Doe\",\r\n \"role\": \"Software Engineer\",\r\n \"description\": \"Experienced developer\",\r\n \"headshotImage\": \"{{assetId}}\",\r\n \"bodyImage\": \"{{assetId}}\"\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/personas", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "personas" - ] - } - }, - "response": [] - }, - { - "name": "personas/{slug}", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/personas/{{personaSlug}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "personas", - "{{personaSlug}}" - ] - } - }, - "response": [] - }, - { - "name": "personas/{slug}", - "request": { - "method": "PUT", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"NEW_NAME2\",\r\n \"role\": \"Software Engineer\",\r\n \"description\": \"Experienced developer\",\r\n \"bodyImage\": \"{{assetId}}\"\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/personas/{{personaSlug}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "personas", - "{{personaSlug}}" - ] - } - }, - "response": [] - }, - { - "name": "personas/{slug}", - "request": { - "method": "DELETE", - "header": [], - "url": { - "raw": "{{baseUrl}}/personas/{{personaSlug}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "personas", - "{{personaSlug}}" - ] - } - }, - "response": [] - } - ] - }, - { - "name": "scenarios/issuance", - "item": [ - { - "name": "scenarios/issuances", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/issuances", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances", - "request": { - "method": "POST", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"example_name\",\r\n \"description\": \"example_description\",\r\n \"issuer\": \"{{issuerId}}\",\r\n \"steps\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"description\": \"example_description\",\r\n \"order\": 1,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\",\r\n \"proofRequest\": {\r\n \"attributes\": {\r\n \"attribute1\": {\r\n \"attributes\": [\"attribute1\", \"attribute2\"],\r\n \"restrictions\": [\"restriction1\", \"restriction2\"]\r\n }\r\n },\r\n \"predicates\": {\r\n \"predicate1\": {\r\n \"name\": \"example_name\",\r\n \"type\": \"example_type\",\r\n \"value\":\"example_value\",\r\n \"restrictions\": [\"restriction1\",\"restriction2\"]\r\n }\r\n }\r\n }\r\n }\r\n ]\r\n }\r\n ],\r\n \"personas\": [\"{{personaId}}\"]\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/scenarios/issuances", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances/{slug}", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{issuanceScenarioSlug}}" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances/{slug}", - "request": { - "method": "PUT", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"new_name\",\r\n \"description\": \"example_description\",\r\n \"issuer\": \"{{issuerId}}\",\r\n \"steps\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"description\": \"example_description\",\r\n \"order\": 1,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\",\r\n \"proofRequest\": {\r\n \"attributes\": {\r\n \"attribute1\": {\r\n \"attributes\": [\"attribute1\", \"attribute2\"],\r\n \"restrictions\": [\"restriction1\", \"restriction2\"]\r\n }\r\n },\r\n \"predicates\": {\r\n \"predicate1\": {\r\n \"name\": \"example_name\",\r\n \"type\": \"example_type\",\r\n \"value\":\"example_value\",\r\n \"restrictions\": [\"restriction1\",\"restriction2\"]\r\n }\r\n }\r\n }\r\n }\r\n ]\r\n }\r\n ],\r\n \"personas\": [\"{{personaId}}\"]\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{issuanceScenarioSlug}}" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances/{slug}", - "request": { - "method": "DELETE", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{issuanceScenarioSlug}}" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances/{slug}/steps", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{issuanceScenarioSlug}}", - "steps" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances/{slug}/steps", - "request": { - "method": "POST", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"title\": \"example_title\",\r\n \"description\": \"example_description\",\r\n \"order\": 3,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title1\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text1\"\r\n },\r\n {\r\n \"title\": \"example_title2\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text2\"\r\n }\r\n ]\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{issuanceScenarioSlug}}", - "steps" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances/{slug}/steps/{stepId}", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/2bd1657f-8e19-4d37-b1fc-acb1b7252b70", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{issuanceScenarioSlug}}", - "steps", - "2bd1657f-8e19-4d37-b1fc-acb1b7252b70" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances/{slug}/steps/{stepId}", - "request": { - "method": "PUT", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"title\": \"NEW_TITLE\",\r\n \"description\": \"example_description\",\r\n \"order\": 3,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title1\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text1\"\r\n }\r\n ]\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/93cca8a9-3e8b-4e11-b698-a74d6d6811a5", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{issuanceScenarioSlug}}", - "steps", - "93cca8a9-3e8b-4e11-b698-a74d6d6811a5" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances/{slug}/steps/{stepId}", - "request": { - "method": "DELETE", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/93cca8a9-3e8b-4e11-b698-a74d6d6811a5", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{issuanceScenarioSlug}}", - "steps", - "93cca8a9-3e8b-4e11-b698-a74d6d6811a5" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances/{slug}/steps/{stepId}/actions", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/cb6f7161-cadc-459a-9469-dab91c057c1d/actions", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{issuanceScenarioSlug}}", - "steps", - "cb6f7161-cadc-459a-9469-dab91c057c1d", - "actions" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances/{slug}/steps/{stepId}/actions", - "request": { - "method": "POST", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"title\": \"example_title\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\"\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/cb6f7161-cadc-459a-9469-dab91c057c1d/actions", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{issuanceScenarioSlug}}", - "steps", - "cb6f7161-cadc-459a-9469-dab91c057c1d", - "actions" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances/{slug}/steps/{stepId}/actions/{actionsId}", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/cb6f7161-cadc-459a-9469-dab91c057c1d/actions/296ba62e-83b6-41f8-91aa-b92debec21f9", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{issuanceScenarioSlug}}", - "steps", - "cb6f7161-cadc-459a-9469-dab91c057c1d", - "actions", - "296ba62e-83b6-41f8-91aa-b92debec21f9" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances/{slug}/steps/{stepId}/actions/{actionsId}", - "request": { - "method": "PUT", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"title\": \"NEW_TITLE\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\"\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/cb6f7161-cadc-459a-9469-dab91c057c1d/actions/296ba62e-83b6-41f8-91aa-b92debec21f9", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{issuanceScenarioSlug}}", - "steps", - "cb6f7161-cadc-459a-9469-dab91c057c1d", - "actions", - "296ba62e-83b6-41f8-91aa-b92debec21f9" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances/{slug}/steps/{stepId}/actions/{actionsId}", - "request": { - "method": "DELETE", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/cb6f7161-cadc-459a-9469-dab91c057c1d/actions/296ba62e-83b6-41f8-91aa-b92debec21f9", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{issuanceScenarioSlug}}", - "steps", - "cb6f7161-cadc-459a-9469-dab91c057c1d", - "actions", - "296ba62e-83b6-41f8-91aa-b92debec21f9" - ] - } - }, - "response": [] - } - ] - }, - { - "name": "scenarios/presentation", - "item": [ - { - "name": "scenarios/presentations", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/presentations", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentations", - "request": { - "method": "POST", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"example_name\",\r\n \"description\": \"example_description\",\r\n \"relyingParty\": \"{{relyingPartyId}}\",\r\n \"steps\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"description\": \"example_description\",\r\n \"order\": 1,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\",\r\n \"proofRequest\": {\r\n \"attributes\": {\r\n \"attribute1\": {\r\n \"attributes\": [\"attribute1\", \"attribute2\"],\r\n \"restrictions\": [\"restriction1\", \"restriction2\"]\r\n }\r\n },\r\n \"predicates\": {\r\n \"predicate1\": {\r\n \"name\": \"example_name\",\r\n \"type\": \"example_type\",\r\n \"value\":\"example_value\",\r\n \"restrictions\": [\"restriction1\",\"restriction2\"]\r\n }\r\n }\r\n }\r\n }\r\n ]\r\n }\r\n ],\r\n \"personas\": [\"{{personaId}}\"]\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/scenarios/presentations", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentations/{slug}", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations", - "{{presentationScenarioSlug}}" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentations/{slug}", - "request": { - "method": "PUT", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"NEW_NAME\",\r\n \"description\": \"example_description\",\r\n \"relyingParty\": \"{{relyingPartyId}}\",\r\n \"steps\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"description\": \"example_description\",\r\n \"order\": 1,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\",\r\n \"proofRequest\": {\r\n \"attributes\": {\r\n \"attribute1\": {\r\n \"attributes\": [\"attribute1\", \"attribute2\"],\r\n \"restrictions\": [\"restriction1\", \"restriction2\"]\r\n }\r\n },\r\n \"predicates\": {\r\n \"predicate1\": {\r\n \"name\": \"example_name\",\r\n \"type\": \"example_type\",\r\n \"value\":\"example_value\",\r\n \"restrictions\": [\"restriction1\",\"restriction2\"]\r\n }\r\n }\r\n }\r\n }\r\n ]\r\n }\r\n ],\r\n \"personas\": [\"{{personaId}}\"]\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations", - "{{presentationScenarioSlug}}" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentation/{slug}", - "request": { - "method": "DELETE", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations", - "{{presentationScenarioSlug}}" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentations/{slug}/steps", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{presentationScenarioSlug}}/steps", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{presentationScenarioSlug}}", - "steps" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentations/slug}/steps", - "request": { - "method": "POST", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"title\": \"example_title\",\r\n \"description\": \"example_description\",\r\n \"order\": 4,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title1\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text1\"\r\n },\r\n {\r\n \"title\": \"example_title2\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text2\"\r\n }\r\n ]\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations", - "{{presentationScenarioSlug}}", - "steps" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentations/{slug}/steps/{stepId}", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/d53b31b4-70a8-4d2a-9ecb-7ab5a591429d", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations", - "{{presentationScenarioSlug}}", - "steps", - "d53b31b4-70a8-4d2a-9ecb-7ab5a591429d" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentations/{slug}/steps/{stepId}", - "request": { - "method": "PUT", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"title\": \"NEW_TITLE\",\r\n \"description\": \"example_description\",\r\n \"order\": 3,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title1\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text1\"\r\n }\r\n ]\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/d53b31b4-70a8-4d2a-9ecb-7ab5a591429d", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations", - "{{presentationScenarioSlug}}", - "steps", - "d53b31b4-70a8-4d2a-9ecb-7ab5a591429d" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentations/{slug}/steps/{stepId}", - "request": { - "method": "DELETE", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/d53b31b4-70a8-4d2a-9ecb-7ab5a591429d", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations", - "{{presentationScenarioSlug}}", - "steps", - "d53b31b4-70a8-4d2a-9ecb-7ab5a591429d" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentations/{slug}/steps/{stepId}/actions", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/b6873c21-1275-4764-bf63-fe87c98890c7/actions", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations", - "{{presentationScenarioSlug}}", - "steps", - "b6873c21-1275-4764-bf63-fe87c98890c7", - "actions" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentations/{slug}/steps/{stepId}/actions", - "request": { - "method": "POST", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"title\": \"example_title\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\"\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/b6873c21-1275-4764-bf63-fe87c98890c7/actions", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations", - "{{presentationScenarioSlug}}", - "steps", - "b6873c21-1275-4764-bf63-fe87c98890c7", - "actions" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentations/{slug}/steps/{stepId}/actions/{actionsId}", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/cd1a0200-2b66-45a7-9d7e-c92887bf86a4/actions/fffc15db-b4e3-45ef-84b0-6e256ae50065", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations", - "{{presentationScenarioSlug}}", - "steps", - "cd1a0200-2b66-45a7-9d7e-c92887bf86a4", - "actions", - "fffc15db-b4e3-45ef-84b0-6e256ae50065" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentations/{slug}/steps/{stepId}/actions/{actionsId}", - "request": { - "method": "PUT", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"title\": \"NEW_TITLE\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\"\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/cd1a0200-2b66-45a7-9d7e-c92887bf86a4/actions/fffc15db-b4e3-45ef-84b0-6e256ae50065", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations", - "{{presentationScenarioSlug}}", - "steps", - "cd1a0200-2b66-45a7-9d7e-c92887bf86a4", - "actions", - "fffc15db-b4e3-45ef-84b0-6e256ae50065" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentations/{slug}/steps/{stepId}/actions/{actionsId}", - "request": { - "method": "DELETE", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/cd1a0200-2b66-45a7-9d7e-c92887bf86a4/actions/fffc15db-b4e3-45ef-84b0-6e256ae50065", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations", - "{{presentationScenarioSlug}}", - "steps", - "cd1a0200-2b66-45a7-9d7e-c92887bf86a4", - "actions", - "fffc15db-b4e3-45ef-84b0-6e256ae50065" - ] - } - }, - "response": [] - } - ] - }, - { - "name": "showcases", - "item": [ - { - "name": "showcases", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/showcases", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "showcases" - ] - } - }, - "response": [] - }, - { - "name": "showcases", - "request": { - "method": "POST", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"example_name\",\r\n \"description\": \"example_description\",\r\n \"status\": \"ACTIVE\",\r\n \"hidden\": false,\r\n \"scenarios\": [\"{{issuanceScenarioId}}\", \"{{presentationScenarioId}}\"],\r\n \"credentialDefinitions\": [\"{{credentialDefinitionId}}\"],\r\n \"personas\": [\"{{personaId}}\"]\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "http://localhost:3000/showcases", - "protocol": "http", - "host": [ - "localhost" - ], - "port": "3000", - "path": [ - "showcases" - ] - } - }, - "response": [] - }, - { - "name": "showcases/{slug}", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/showcases/{{showcaseSlug}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "showcases", - "{{showcaseSlug}}" - ] - } - }, - "response": [] - }, - { - "name": "showcases/{slug}", - "request": { - "method": "PUT", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"new_name\",\r\n \"description\": \"example_description\",\r\n \"status\": \"ACTIVE\",\r\n \"hidden\": false,\r\n \"scenarios\": [\"{{issuanceScenarioId}}\", \"{{presentationScenarioId}}\"],\r\n \"credentialDefinitions\": [\"{{credentialDefinitionId}}\"],\r\n \"personas\": [\"{{personaId}}\"]\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/showcases/{{showcaseSlug}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "showcases", - "{{showcaseSlug}}" - ] - } - }, - "response": [] - }, - { - "name": "showcases/{slug}", - "request": { - "method": "DELETE", - "header": [], - "url": { - "raw": "{{baseUrl}}/showcases/{{showcaseSlug}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "showcases", - "{{showcaseSlug}}" - ] - } - }, - "response": [] - } - ] - } - ] + "info": { + "_postman_id": "4658d37d-77a6-486a-aaf1-4f3f7cbd76f7", + "name": "credential-showcase-api", + "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json", + "_exporter_id": "10630815" + }, + "item": [ + { + "name": "assets", + "item": [ + { + "name": "assets", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/assets", + "host": ["{{baseUrl}}"], + "path": ["assets"] + } + }, + "response": [] + }, + { + "name": "asset", + "request": { + "method": "POST", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"mediaType\": \"image/jpeg\",\r\n \"content\": \"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\"\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/assets", + "host": ["{{baseUrl}}"], + "path": ["assets"] + } + }, + "response": [] + }, + { + "name": "asset/{id}", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/assets/{{assetId}}", + "host": ["{{baseUrl}}"], + "path": ["assets", "{{assetId}}"] + } + }, + "response": [] + }, + { + "name": "asset/{id}", + "request": { + "method": "PUT", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"mediaType\": \"image/jpeg\",\r\n \"fileName\": \"cat3.jpg\",\r\n \"content\": \"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\"\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/assets/{{assetId}}", + "host": ["{{baseUrl}}"], + "path": ["assets", "{{assetId}}"] + } + }, + "response": [] + }, + { + "name": "asset/{id}", + "request": { + "method": "DELETE", + "header": [], + "url": { + "raw": "{{baseUrl}}/assets/{{assetId}}", + "host": ["{{baseUrl}}"], + "path": ["assets", "{{assetId}}"] + } + }, + "response": [] + } + ] + }, + { + "name": "credentials/schemas", + "item": [ + { + "name": "credentials/schemas", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/credentials/schemas", + "host": ["{{baseUrl}}"], + "path": ["credentials", "schemas"] + } + }, + "response": [] + }, + { + "name": "credentials/schemas", + "request": { + "method": "POST", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"example_name\",\r\n \"version\": \"example_version\",\r\n \"identifierType\": \"DID\",\r\n \"identifier\": \"did:sov:XUeUZauFLeBNofY3NhaZCB\",\r\n \"attributes\": [\r\n {\r\n \"name\": \"example_attribute_name1\",\r\n \"value\": \"example_attribute_value1\",\r\n \"type\": \"STRING\"\r\n }\r\n ]\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/credentials/schemas", + "host": ["{{baseUrl}}"], + "path": ["credentials", "schemas"] + } + }, + "response": [] + }, + { + "name": "credentials/schemas/{id}", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/credentials/schemas/{{credentialSchemaId}}", + "host": ["{{baseUrl}}"], + "path": ["credentials", "schemas", "{{credentialSchemaId}}"] + } + }, + "response": [] + }, + { + "name": "credentials/schemas/{id}", + "request": { + "method": "PUT", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"new_name\",\r\n \"version\": \"example_version\",\r\n \"identifierType\": \"DID\",\r\n \"identifier\": \"did:sov:XUeUZauFLeBNofY3NhaZCB\",\r\n \"attributes\": [\r\n {\r\n \"name\": \"example_attribute_name1\",\r\n \"value\": \"example_attribute_value1\",\r\n \"type\": \"STRING\"\r\n }\r\n ]\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/credentials/schemas/{{credentialSchemaId}}", + "host": ["{{baseUrl}}"], + "path": ["credentials", "schemas", "{{credentialSchemaId}}"] + } + }, + "response": [] + }, + { + "name": "credentials/schemas/{id}", + "request": { + "method": "DELETE", + "header": [], + "url": { + "raw": "{{baseUrl}}/credentials/schemas/{{credentialSchemaId}}", + "host": ["{{baseUrl}}"], + "path": ["credentials", "schemas", "{{credentialSchemaId}}"] + } + }, + "response": [] + } + ] + }, + { + "name": "credentials/definitions", + "item": [ + { + "name": "credentials/definitions", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/credentials/definitions", + "host": ["{{baseUrl}}"], + "path": ["credentials", "definitions"] + } + }, + "response": [] + }, + { + "name": "credentials/definitions", + "request": { + "method": "POST", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"example_name\",\r\n \"version\": \"example_version\",\r\n \"icon\": \"{{assetId}}\",\r\n \"identifierType\": \"DID\",\r\n \"identifier\": \"did:sov:XUeUZauFLeBNofY3NhaZCB\",\r\n \"type\": \"ANONCRED\",\r\n \"credentialSchema\": \"{{credentialSchemaId}}\",\r\n \"revocation\": {\r\n \"title\": \"example_revocation_title\",\r\n \"description\": \"example_revocation_description\"\r\n }\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/credentials/definitions", + "host": ["{{baseUrl}}"], + "path": ["credentials", "definitions"] + } + }, + "response": [] + }, + { + "name": "credentials/definitions/{id}", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/credentials/definitions/{{credentialDefinitionId}}", + "host": ["{{baseUrl}}"], + "path": ["credentials", "definitions", "{{credentialDefinitionId}}"] + } + }, + "response": [] + }, + { + "name": "credentials/definitions/{id}", + "request": { + "method": "PUT", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"NEW_NAME\",\r\n \"version\": \"example_version\",\r\n \"icon\": \"{{assetId}}\",\r\n \"identifierType\": \"DID\",\r\n \"identifier\": \"did:sov:XUeUZauFLeBNofY3NhaZCB\",\r\n \"type\": \"ANONCRED\",\r\n \"credentialSchema\": \"{{credentialSchemaId}}\",\r\n \"revocation\": {\r\n \"title\": \"example_revocation_title\",\r\n \"description\": \"example_revocation_description\"\r\n }\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/credentials/definitions/{{credentialDefinitionId}}", + "host": ["{{baseUrl}}"], + "path": ["credentials", "definitions", "{{credentialDefinitionId}}"] + } + }, + "response": [] + }, + { + "name": "credentials/definitions/{id}", + "request": { + "method": "DELETE", + "header": [], + "url": { + "raw": "{{baseUrl}}/credentials/definitions/{{credentialDefinitionId}}", + "host": ["{{baseUrl}}"], + "path": ["credentials", "definitions", "{{credentialDefinitionId}}"] + } + }, + "response": [] + } + ] + }, + { + "name": "relying-parties", + "item": [ + { + "name": "relying-parties", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/roles/relying-parties", + "host": ["{{baseUrl}}"], + "path": ["roles", "relying-parties"] + } + }, + "response": [] + }, + { + "name": "relying-parties", + "request": { + "method": "POST", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"example_name\",\r\n \"type\": \"ARIES\",\r\n \"credentialDefinitions\": [\"{{credentialDefinitionId}}\"],\r\n \"description\": \"example_description\",\r\n \"organization\": \"example_organization\",\r\n \"logo\": \"{{assetId}}\"\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "http://localhost:3000/roles/relying-parties", + "protocol": "http", + "host": ["localhost"], + "port": "3000", + "path": ["roles", "relying-parties"] + } + }, + "response": [] + }, + { + "name": "relying-parties/{id}", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/roles/relying-parties/{{relyingPartyId}}", + "host": ["{{baseUrl}}"], + "path": ["roles", "relying-parties", "{{relyingPartyId}}"] + } + }, + "response": [] + }, + { + "name": "relying-parties/{id}", + "request": { + "method": "PUT", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"NEW NAME\",\r\n \"type\": \"ARIES\",\r\n \"credentialDefinitions\": [\"{{credentialDefinitionId}}\"],\r\n \"description\": \"example_description\",\r\n \"organization\": \"example_organization\",\r\n \"logo\": \"{{assetId}}\"\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/roles/relying-parties/{{relyingPartyId}}", + "host": ["{{baseUrl}}"], + "path": ["roles", "relying-parties", "{{relyingPartyId}}"] + } + }, + "response": [] + }, + { + "name": "relying-parties/{id}", + "request": { + "method": "DELETE", + "header": [], + "url": { + "raw": "{{relyingPartyId}}/roles/relying-parties/{{relyingPartyId}}", + "host": ["{{relyingPartyId}}"], + "path": ["roles", "relying-parties", "{{relyingPartyId}}"] + } + }, + "response": [] + } + ] + }, + { + "name": "issuers", + "item": [ + { + "name": "issuers", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/roles/issuers", + "host": ["{{baseUrl}}"], + "path": ["roles", "issuers"] + } + }, + "response": [] + }, + { + "name": "issuers", + "request": { + "method": "POST", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"example_name\",\r\n \"type\": \"ARIES\",\r\n \"credentialDefinitions\": [\"{{credentialDefinitionId}}\"],\r\n \"credentialSchemas\": [\"{{credentialSchemaId}}\"],\r\n \"description\": \"example_description\",\r\n \"organization\": \"example_organization\",\r\n \"logo\": \"{{assetId}}\"\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/roles/issuers", + "host": ["{{baseUrl}}"], + "path": ["roles", "issuers"] + } + }, + "response": [] + }, + { + "name": "issuers/{id}", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/roles/issuers/{{issuerId}}", + "host": ["{{baseUrl}}"], + "path": ["roles", "issuers", "{{issuerId}}"] + } + }, + "response": [] + }, + { + "name": "issuers/{id}", + "request": { + "method": "PUT", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"new_name\",\r\n \"type\": \"ARIES\",\r\n \"credentialDefinitions\": [\"{{credentialDefinitionId}}\"],\r\n \"credentialSchemas\": [\"{{credentialSchemaId}}\"],\r\n \"description\": \"example_description\",\r\n \"organization\": \"example_organization\",\r\n \"logo\": \"{{assetId}}\"\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/roles/issuers/{{issuerId}}", + "host": ["{{baseUrl}}"], + "path": ["roles", "issuers", "{{issuerId}}"] + } + }, + "response": [] + }, + { + "name": "issuers/{id}", + "request": { + "method": "DELETE", + "header": [], + "url": { + "raw": "http://localhost:3000/roles/issuers/{{issuerId}}", + "protocol": "http", + "host": ["localhost"], + "port": "3000", + "path": ["roles", "issuers", "{{issuerId}}"] + } + }, + "response": [] + } + ] + }, + { + "name": "personas", + "item": [ + { + "name": "personas", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/personas", + "host": ["{{baseUrl}}"], + "path": ["personas"] + } + }, + "response": [] + }, + { + "name": "personas", + "request": { + "method": "POST", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"John Doe\",\r\n \"role\": \"Software Engineer\",\r\n \"description\": \"Experienced developer\",\r\n \"headshotImage\": \"{{assetId}}\",\r\n \"bodyImage\": \"{{assetId}}\"\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/personas", + "host": ["{{baseUrl}}"], + "path": ["personas"] + } + }, + "response": [] + }, + { + "name": "personas/{slug}", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/personas/{{personaSlug}}", + "host": ["{{baseUrl}}"], + "path": ["personas", "{{personaSlug}}"] + } + }, + "response": [] + }, + { + "name": "personas/{slug}", + "request": { + "method": "PUT", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"NEW_NAME2\",\r\n \"role\": \"Software Engineer\",\r\n \"description\": \"Experienced developer\",\r\n \"bodyImage\": \"{{assetId}}\"\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/personas/{{personaSlug}}", + "host": ["{{baseUrl}}"], + "path": ["personas", "{{personaSlug}}"] + } + }, + "response": [] + }, + { + "name": "personas/{slug}", + "request": { + "method": "DELETE", + "header": [], + "url": { + "raw": "{{baseUrl}}/personas/{{personaSlug}}", + "host": ["{{baseUrl}}"], + "path": ["personas", "{{personaSlug}}"] + } + }, + "response": [] + } + ] + }, + { + "name": "scenarios/issuance", + "item": [ + { + "name": "scenarios/issuances", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/issuances", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "issuances"] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances", + "request": { + "method": "POST", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"example_name\",\r\n \"description\": \"example_description\",\r\n \"issuer\": \"{{issuerId}}\",\r\n \"steps\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"description\": \"example_description\",\r\n \"order\": 1,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\",\r\n \"proofRequest\": {\r\n \"attributes\": {\r\n \"attribute1\": {\r\n \"attributes\": [\"attribute1\", \"attribute2\"],\r\n \"restrictions\": [\"restriction1\", \"restriction2\"]\r\n }\r\n },\r\n \"predicates\": {\r\n \"predicate1\": {\r\n \"name\": \"example_name\",\r\n \"type\": \"example_type\",\r\n \"value\":\"example_value\",\r\n \"restrictions\": [\"restriction1\",\"restriction2\"]\r\n }\r\n }\r\n }\r\n }\r\n ]\r\n }\r\n ],\r\n \"personas\": [\"{{personaId}}\"]\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/scenarios/issuances", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "issuances"] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances/{slug}", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "issuances", "{{issuanceScenarioSlug}}"] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances/{slug}", + "request": { + "method": "PUT", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"new_name\",\r\n \"description\": \"example_description\",\r\n \"issuer\": \"{{issuerId}}\",\r\n \"steps\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"description\": \"example_description\",\r\n \"order\": 1,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\",\r\n \"proofRequest\": {\r\n \"attributes\": {\r\n \"attribute1\": {\r\n \"attributes\": [\"attribute1\", \"attribute2\"],\r\n \"restrictions\": [\"restriction1\", \"restriction2\"]\r\n }\r\n },\r\n \"predicates\": {\r\n \"predicate1\": {\r\n \"name\": \"example_name\",\r\n \"type\": \"example_type\",\r\n \"value\":\"example_value\",\r\n \"restrictions\": [\"restriction1\",\"restriction2\"]\r\n }\r\n }\r\n }\r\n }\r\n ]\r\n }\r\n ],\r\n \"personas\": [\"{{personaId}}\"]\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "issuances", "{{issuanceScenarioSlug}}"] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances/{slug}", + "request": { + "method": "DELETE", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "issuances", "{{issuanceScenarioSlug}}"] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances/{slug}/steps", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "issuances", "{{issuanceScenarioSlug}}", "steps"] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances/{slug}/steps", + "request": { + "method": "POST", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"title\": \"example_title\",\r\n \"description\": \"example_description\",\r\n \"order\": 3,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title1\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text1\"\r\n },\r\n {\r\n \"title\": \"example_title2\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text2\"\r\n }\r\n ]\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "issuances", "{{issuanceScenarioSlug}}", "steps"] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances/{slug}/steps/{stepId}", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/2bd1657f-8e19-4d37-b1fc-acb1b7252b70", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "issuances", "{{issuanceScenarioSlug}}", "steps", "2bd1657f-8e19-4d37-b1fc-acb1b7252b70"] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances/{slug}/steps/{stepId}", + "request": { + "method": "PUT", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"title\": \"NEW_TITLE\",\r\n \"description\": \"example_description\",\r\n \"order\": 3,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title1\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text1\"\r\n }\r\n ]\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/93cca8a9-3e8b-4e11-b698-a74d6d6811a5", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "issuances", "{{issuanceScenarioSlug}}", "steps", "93cca8a9-3e8b-4e11-b698-a74d6d6811a5"] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances/{slug}/steps/{stepId}", + "request": { + "method": "DELETE", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/93cca8a9-3e8b-4e11-b698-a74d6d6811a5", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "issuances", "{{issuanceScenarioSlug}}", "steps", "93cca8a9-3e8b-4e11-b698-a74d6d6811a5"] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances/{slug}/steps/{stepId}/actions", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/cb6f7161-cadc-459a-9469-dab91c057c1d/actions", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "issuances", "{{issuanceScenarioSlug}}", "steps", "cb6f7161-cadc-459a-9469-dab91c057c1d", "actions"] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances/{slug}/steps/{stepId}/actions", + "request": { + "method": "POST", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"title\": \"example_title\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\"\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/cb6f7161-cadc-459a-9469-dab91c057c1d/actions", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "issuances", "{{issuanceScenarioSlug}}", "steps", "cb6f7161-cadc-459a-9469-dab91c057c1d", "actions"] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances/{slug}/steps/{stepId}/actions/{actionsId}", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/cb6f7161-cadc-459a-9469-dab91c057c1d/actions/296ba62e-83b6-41f8-91aa-b92debec21f9", + "host": ["{{baseUrl}}"], + "path": [ + "scenarios", + "issuances", + "{{issuanceScenarioSlug}}", + "steps", + "cb6f7161-cadc-459a-9469-dab91c057c1d", + "actions", + "296ba62e-83b6-41f8-91aa-b92debec21f9" + ] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances/{slug}/steps/{stepId}/actions/{actionsId}", + "request": { + "method": "PUT", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"title\": \"NEW_TITLE\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\"\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/cb6f7161-cadc-459a-9469-dab91c057c1d/actions/296ba62e-83b6-41f8-91aa-b92debec21f9", + "host": ["{{baseUrl}}"], + "path": [ + "scenarios", + "issuances", + "{{issuanceScenarioSlug}}", + "steps", + "cb6f7161-cadc-459a-9469-dab91c057c1d", + "actions", + "296ba62e-83b6-41f8-91aa-b92debec21f9" + ] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances/{slug}/steps/{stepId}/actions/{actionsId}", + "request": { + "method": "DELETE", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/cb6f7161-cadc-459a-9469-dab91c057c1d/actions/296ba62e-83b6-41f8-91aa-b92debec21f9", + "host": ["{{baseUrl}}"], + "path": [ + "scenarios", + "issuances", + "{{issuanceScenarioSlug}}", + "steps", + "cb6f7161-cadc-459a-9469-dab91c057c1d", + "actions", + "296ba62e-83b6-41f8-91aa-b92debec21f9" + ] + } + }, + "response": [] + } + ] + }, + { + "name": "scenarios/presentation", + "item": [ + { + "name": "scenarios/presentations", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/presentations", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "presentations"] + } + }, + "response": [] + }, + { + "name": "scenarios/presentations", + "request": { + "method": "POST", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"example_name\",\r\n \"description\": \"example_description\",\r\n \"relyingParty\": \"{{relyingPartyId}}\",\r\n \"steps\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"description\": \"example_description\",\r\n \"order\": 1,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\",\r\n \"proofRequest\": {\r\n \"attributes\": {\r\n \"attribute1\": {\r\n \"attributes\": [\"attribute1\", \"attribute2\"],\r\n \"restrictions\": [\"restriction1\", \"restriction2\"]\r\n }\r\n },\r\n \"predicates\": {\r\n \"predicate1\": {\r\n \"name\": \"example_name\",\r\n \"type\": \"example_type\",\r\n \"value\":\"example_value\",\r\n \"restrictions\": [\"restriction1\",\"restriction2\"]\r\n }\r\n }\r\n }\r\n }\r\n ]\r\n }\r\n ],\r\n \"personas\": [\"{{personaId}}\"]\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/scenarios/presentations", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "presentations"] + } + }, + "response": [] + }, + { + "name": "scenarios/presentations/{slug}", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "presentations", "{{presentationScenarioSlug}}"] + } + }, + "response": [] + }, + { + "name": "scenarios/presentations/{slug}", + "request": { + "method": "PUT", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"NEW_NAME\",\r\n \"description\": \"example_description\",\r\n \"relyingParty\": \"{{relyingPartyId}}\",\r\n \"steps\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"description\": \"example_description\",\r\n \"order\": 1,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\",\r\n \"proofRequest\": {\r\n \"attributes\": {\r\n \"attribute1\": {\r\n \"attributes\": [\"attribute1\", \"attribute2\"],\r\n \"restrictions\": [\"restriction1\", \"restriction2\"]\r\n }\r\n },\r\n \"predicates\": {\r\n \"predicate1\": {\r\n \"name\": \"example_name\",\r\n \"type\": \"example_type\",\r\n \"value\":\"example_value\",\r\n \"restrictions\": [\"restriction1\",\"restriction2\"]\r\n }\r\n }\r\n }\r\n }\r\n ]\r\n }\r\n ],\r\n \"personas\": [\"{{personaId}}\"]\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "presentations", "{{presentationScenarioSlug}}"] + } + }, + "response": [] + }, + { + "name": "scenarios/presentation/{slug}", + "request": { + "method": "DELETE", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "presentations", "{{presentationScenarioSlug}}"] + } + }, + "response": [] + }, + { + "name": "scenarios/presentations/{slug}/steps", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{presentationScenarioSlug}}/steps", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "issuances", "{{presentationScenarioSlug}}", "steps"] + } + }, + "response": [] + }, + { + "name": "scenarios/presentations/slug}/steps", + "request": { + "method": "POST", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"title\": \"example_title\",\r\n \"description\": \"example_description\",\r\n \"order\": 4,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title1\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text1\"\r\n },\r\n {\r\n \"title\": \"example_title2\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text2\"\r\n }\r\n ]\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "presentations", "{{presentationScenarioSlug}}", "steps"] + } + }, + "response": [] + }, + { + "name": "scenarios/presentations/{slug}/steps/{stepId}", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/d53b31b4-70a8-4d2a-9ecb-7ab5a591429d", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "presentations", "{{presentationScenarioSlug}}", "steps", "d53b31b4-70a8-4d2a-9ecb-7ab5a591429d"] + } + }, + "response": [] + }, + { + "name": "scenarios/presentations/{slug}/steps/{stepId}", + "request": { + "method": "PUT", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"title\": \"NEW_TITLE\",\r\n \"description\": \"example_description\",\r\n \"order\": 3,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title1\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text1\"\r\n }\r\n ]\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/d53b31b4-70a8-4d2a-9ecb-7ab5a591429d", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "presentations", "{{presentationScenarioSlug}}", "steps", "d53b31b4-70a8-4d2a-9ecb-7ab5a591429d"] + } + }, + "response": [] + }, + { + "name": "scenarios/presentations/{slug}/steps/{stepId}", + "request": { + "method": "DELETE", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/d53b31b4-70a8-4d2a-9ecb-7ab5a591429d", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "presentations", "{{presentationScenarioSlug}}", "steps", "d53b31b4-70a8-4d2a-9ecb-7ab5a591429d"] + } + }, + "response": [] + }, + { + "name": "scenarios/presentations/{slug}/steps/{stepId}/actions", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/b6873c21-1275-4764-bf63-fe87c98890c7/actions", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "presentations", "{{presentationScenarioSlug}}", "steps", "b6873c21-1275-4764-bf63-fe87c98890c7", "actions"] + } + }, + "response": [] + }, + { + "name": "scenarios/presentations/{slug}/steps/{stepId}/actions", + "request": { + "method": "POST", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"title\": \"example_title\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\"\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/b6873c21-1275-4764-bf63-fe87c98890c7/actions", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "presentations", "{{presentationScenarioSlug}}", "steps", "b6873c21-1275-4764-bf63-fe87c98890c7", "actions"] + } + }, + "response": [] + }, + { + "name": "scenarios/presentations/{slug}/steps/{stepId}/actions/{actionsId}", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/cd1a0200-2b66-45a7-9d7e-c92887bf86a4/actions/fffc15db-b4e3-45ef-84b0-6e256ae50065", + "host": ["{{baseUrl}}"], + "path": [ + "scenarios", + "presentations", + "{{presentationScenarioSlug}}", + "steps", + "cd1a0200-2b66-45a7-9d7e-c92887bf86a4", + "actions", + "fffc15db-b4e3-45ef-84b0-6e256ae50065" + ] + } + }, + "response": [] + }, + { + "name": "scenarios/presentations/{slug}/steps/{stepId}/actions/{actionsId}", + "request": { + "method": "PUT", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"title\": \"NEW_TITLE\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\"\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/cd1a0200-2b66-45a7-9d7e-c92887bf86a4/actions/fffc15db-b4e3-45ef-84b0-6e256ae50065", + "host": ["{{baseUrl}}"], + "path": [ + "scenarios", + "presentations", + "{{presentationScenarioSlug}}", + "steps", + "cd1a0200-2b66-45a7-9d7e-c92887bf86a4", + "actions", + "fffc15db-b4e3-45ef-84b0-6e256ae50065" + ] + } + }, + "response": [] + }, + { + "name": "scenarios/presentations/{slug}/steps/{stepId}/actions/{actionsId}", + "request": { + "method": "DELETE", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/cd1a0200-2b66-45a7-9d7e-c92887bf86a4/actions/fffc15db-b4e3-45ef-84b0-6e256ae50065", + "host": ["{{baseUrl}}"], + "path": [ + "scenarios", + "presentations", + "{{presentationScenarioSlug}}", + "steps", + "cd1a0200-2b66-45a7-9d7e-c92887bf86a4", + "actions", + "fffc15db-b4e3-45ef-84b0-6e256ae50065" + ] + } + }, + "response": [] + } + ] + }, + { + "name": "showcases", + "item": [ + { + "name": "showcases", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/showcases", + "host": ["{{baseUrl}}"], + "path": ["showcases"] + } + }, + "response": [] + }, + { + "name": "showcases", + "request": { + "method": "POST", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"example_name\",\r\n \"description\": \"example_description\",\r\n \"status\": \"ACTIVE\",\r\n \"hidden\": false,\r\n \"scenarios\": [\"{{issuanceScenarioId}}\", \"{{presentationScenarioId}}\"],\r\n \"credentialDefinitions\": [\"{{credentialDefinitionId}}\"],\r\n \"personas\": [\"{{personaId}}\"]\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "http://localhost:3000/showcases", + "protocol": "http", + "host": ["localhost"], + "port": "3000", + "path": ["showcases"] + } + }, + "response": [] + }, + { + "name": "showcases/{slug}", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/showcases/{{showcaseSlug}}", + "host": ["{{baseUrl}}"], + "path": ["showcases", "{{showcaseSlug}}"] + } + }, + "response": [] + }, + { + "name": "showcases/{slug}", + "request": { + "method": "PUT", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"new_name\",\r\n \"description\": \"example_description\",\r\n \"status\": \"ACTIVE\",\r\n \"hidden\": false,\r\n \"scenarios\": [\"{{issuanceScenarioId}}\", \"{{presentationScenarioId}}\"],\r\n \"credentialDefinitions\": [\"{{credentialDefinitionId}}\"],\r\n \"personas\": [\"{{personaId}}\"]\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/showcases/{{showcaseSlug}}", + "host": ["{{baseUrl}}"], + "path": ["showcases", "{{showcaseSlug}}"] + } + }, + "response": [] + }, + { + "name": "showcases/{slug}", + "request": { + "method": "DELETE", + "header": [], + "url": { + "raw": "{{baseUrl}}/showcases/{{showcaseSlug}}", + "host": ["{{baseUrl}}"], + "path": ["showcases", "{{showcaseSlug}}"] + } + }, + "response": [] + } + ] + } + ] } diff --git a/postman/credential-showcase-api.postman_environment.json b/postman/credential-showcase-api.postman_environment.json index 9bed8af..4b127a9 100644 --- a/postman/credential-showcase-api.postman_environment.json +++ b/postman/credential-showcase-api.postman_environment.json @@ -1,87 +1,87 @@ { - "id": "0932d044-a32b-4565-91bd-3e7f6e68b166", - "name": "credential-showcase-api", - "values": [ - { - "key": "baseUrl", - "value": "http://localhost:3000", - "type": "default", - "enabled": true - }, - { - "key": "assetId", - "value": "49d11e62-08b5-4d20-85ed-156c4d44d4b3", - "type": "default", - "enabled": true - }, - { - "key": "credentialSchemaId", - "value": "246a8004-84b4-44e6-8f64-8cd5c80d97f0", - "type": "default", - "enabled": true - }, - { - "key": "credentialDefinitionId", - "value": "239c5311-64ba-4638-b25a-c702ffc86370", - "type": "default", - "enabled": true - }, - { - "key": "relyingPartyId", - "value": "baa645ce-3894-45cb-90b1-f091988a3e63", - "type": "default", - "enabled": true - }, - { - "key": "issuerId", - "value": "8c71bf49-9078-4517-bb3f-d999de493562", - "type": "default", - "enabled": true - }, - { - "key": "personaSlug", - "value": "john-doe", - "type": "default", - "enabled": true - }, - { - "key": "personaId", - "value": "8b7e9a24-dbb4-48b8-a944-b035e9307b39", - "type": "default", - "enabled": true - }, - { - "key": "showcaseSlug", - "value": "bc-showcase", - "type": "default", - "enabled": true - }, - { - "key": "issuanceScenarioId", - "value": "00993b2a-8174-4f8e-acf5-dc67f1c7ecf6", - "type": "default", - "enabled": true - }, - { - "key": "issuanceScenarioSlug", - "value": "issuance-scenario", - "type": "default", - "enabled": true - }, - { - "key": "presentationScenarioId", - "value": "5cd165b3-859d-453f-8178-452924dc588a", - "type": "default", - "enabled": true - }, - { - "key": "presentationScenarioSlug", - "value": "presentation-scenario", - "type": "default", - "enabled": true - } - ], - "_postman_variable_scope": "environment", - "_postman_exported_at": "2025-03-10T16:03:12.610Z", - "_postman_exported_using": "Postman/11.35.4" -} \ No newline at end of file + "id": "0932d044-a32b-4565-91bd-3e7f6e68b166", + "name": "credential-showcase-api", + "values": [ + { + "key": "baseUrl", + "value": "http://localhost:3000", + "type": "default", + "enabled": true + }, + { + "key": "assetId", + "value": "49d11e62-08b5-4d20-85ed-156c4d44d4b3", + "type": "default", + "enabled": true + }, + { + "key": "credentialSchemaId", + "value": "246a8004-84b4-44e6-8f64-8cd5c80d97f0", + "type": "default", + "enabled": true + }, + { + "key": "credentialDefinitionId", + "value": "239c5311-64ba-4638-b25a-c702ffc86370", + "type": "default", + "enabled": true + }, + { + "key": "relyingPartyId", + "value": "baa645ce-3894-45cb-90b1-f091988a3e63", + "type": "default", + "enabled": true + }, + { + "key": "issuerId", + "value": "8c71bf49-9078-4517-bb3f-d999de493562", + "type": "default", + "enabled": true + }, + { + "key": "personaSlug", + "value": "john-doe", + "type": "default", + "enabled": true + }, + { + "key": "personaId", + "value": "8b7e9a24-dbb4-48b8-a944-b035e9307b39", + "type": "default", + "enabled": true + }, + { + "key": "showcaseSlug", + "value": "bc-showcase", + "type": "default", + "enabled": true + }, + { + "key": "issuanceScenarioId", + "value": "00993b2a-8174-4f8e-acf5-dc67f1c7ecf6", + "type": "default", + "enabled": true + }, + { + "key": "issuanceScenarioSlug", + "value": "issuance-scenario", + "type": "default", + "enabled": true + }, + { + "key": "presentationScenarioId", + "value": "5cd165b3-859d-453f-8178-452924dc588a", + "type": "default", + "enabled": true + }, + { + "key": "presentationScenarioSlug", + "value": "presentation-scenario", + "type": "default", + "enabled": true + } + ], + "_postman_variable_scope": "environment", + "_postman_exported_at": "2025-03-10T16:03:12.610Z", + "_postman_exported_using": "Postman/11.35.4" +} diff --git a/turbo.json b/turbo.json index 72da009..196df31 100644 --- a/turbo.json +++ b/turbo.json @@ -34,9 +34,7 @@ }, "generate:models": { "dependsOn": ["^generate:models"], - "outputs": [ - "src/**" - ] + "outputs": ["src/**"] } } }