import { type IContentItem, type Elements, createDeliveryClient } from '@kontent-ai/delivery-sdk';

/**
 * Generate models with @kontent-ai/model-generator
 */
export type Movie = IContentItem<{
    readonly title: Elements.TextElement;
    readonly plot: Elements.RichTextElement;
    readonly released: Elements.DateTimeElement;
    readonly length: Elements.NumberElement;
    readonly poster: Elements.AssetsElement;
    readonly category: Elements.MultipleChoiceElement;
    readonly stars: Elements.LinkedItemsElement<Actor>;
    readonly seoname: Elements.UrlSlugElement;
    readonly releasecategory: Elements.TaxonomyElement;
}>;

// initialize delivery client
const deliveryClient = createDeliveryClient({
    environmentId: '<YOUR_ENVIRONMENT_ID>'
});

// fetch items
const response = await deliveryClient.items<Movie>().type('<CONTENT_TYPE_CODENAME>').toPromise();

// read data of first item
const movieText = response.data.items[0].elements.title.value;

import { ElementModels, Elements, createDeliveryClient } from '@kontent-ai/delivery-sdk';

type ColorElement = Elements.CustomElement<{
    red: number;
    green: number;
    blue: number;
}>;

const client = createDeliveryClient({
    environmentId: '<YOUR_ENVIRONMENT_ID>',
    elementResolver: (elementWrapper) => {
        if (elementWrapper.rawElement.type === 'color') {
            const parsed = JSON.parse(elementWrapper.rawElement.value);

            return {
                red: parsed.red,
                green: parsed.green,
                blue: parsed.blue
            };
        }

        return undefined;
    }
});

type Movie = IContentItem<{
    color: ColorElement;
    title: Elements.TextElement;
}>;

// Gets 5 items based on the Movie type
deliveryClient.items<Movie>().type('movie').limitParameter(5).skipParameter(2).toPromise();

// Gets items based on the Movie type with 'Warrior' in their 'Title' element
deliveryClient.items<Movie>().type('movie').equalsFilter('elements.title', 'Warrior').toPromise();

deliveryClient.items<Movie>().type('movie').orderByDescending('elements.title').toPromise();
deliveryClient.items<Movie>().type('movie').orderByAscending('elements.title').toPromise();
deliveryClient.items<Movie>().type('movie').orderParameter('elements.title', 'desc').toPromise();

deliveryClient
    .items<Movie>()
    .withUrl('https://deliver.kontent.ai/da5abe9f-fdad-4168-97cd-b3464be2ccb9/items?system.type=movie')
    .toPromise();

deliveryClient.items<Movie>().withParameter('name', 'value').toPromise();

import { createDeliveryClient } from '@kontent-ai/delivery-sdk';

var deliveryClient = new createDeliveryClient({
    environmentId: '<YOUR_ENVIRONMENT_ID>',
    defaultLanguage: 'es'
});

// Gets items in 'es' language because it is marked as default
deliveryClient.item('warrior').toPromise();

// Gets items in 'en' language because language parameter has priority over the default one
deliveryClient.item('warrior').languageParameter(`en`).toPromise();

import { createDeliveryClient } from '@kontent-ai/delivery-sdk';

const deliveryClient = createDeliveryClient({
  environmentId: '<YOUR_ENVIRONMENT_ID>';
  previewApiKey: '<YOUR_PREVIEW_API_KEY>',
  defaultQueryConfig: {
    usePreviewMode: true
  }
});

deliveryClient
    .items()
    .queryConfig({
        usePreviewMode: true
    })
    .toPromise();

import { createDeliveryClient } from '@kontent-ai/delivery-sdk';

const deliveryClient = createDeliveryClient({
  environmentId: '<YOUR_ENVIRONMENT_ID>';
  secureApiKey: '<YOUR_SECURE_ACCESS_KEY>',
    defaultQueryConfig: {
      // Enabled secure access for all queries
      useSecuredMode: true
  }
});

deliveryClient
    .items()
    .queryConfig({
        // Enables secure access only for this query
        useSecuredMode: true
    })
    .toPromise();

import { transformImageUrl } from '@kontent-ai/delivery-sdk';

// Sample asset URL; You'll find URLs like these in asset and rich text elements
const assetUrl = `https://assets-eu-01.kc-usercontent.com/ede994d8-bb05-01b5-9c33-8b65e7372306/4f45e0a8-4fc3-4143-a81f-55b7e4ce7daa/warrior.jpg`;

const transformedUrl = transformImageUrl(assetUrl)
    .withDpr(2)
    .withCompression('lossless')
    .withQuality(4)
    .withHeight(200)
    .withWidth(100)
    .getUrl();

// this executed multiple HTTP requests until it gets all items
const response = await deliveryClient.items().limitParameter(5).toAllPromise();

// only gets 3 pages at maximum
const response = await deliveryClient.items().limitParameter(5).toAllPromise({
    pages: 3
});

deliveryClient.type('movie').toPromise();
deliveryClient.types().toPromise();
deliveryClient.types().toAllPromise();

deliveryClient.taxonomy('taxonomyGroupName').toPromise();
deliveryClient.taxonomies().toPromise();
deliveryClient.taxonomies().toAllPromise();

const client = createDeliveryClient({
    environmentId: '<YOUR_ENVIRONMENT_ID>',
    // Will be used instead of 'https://deliver.kontent.ai' for all requests.
    // Parameters, filters, project Id and other parts of the URL will use default values.
    proxy: {
        baseUrl: 'http://my-proxy.io'
    }
});

const client = createDeliveryClient({
    environmentId: '<YOUR_ENVIRONMENT_ID>',
    proxy: {
        advancedProxyUrlResolver: (data) => {
            const action = data.action; // /items
            const domain = data.domain; // https://deliver.kontent.ai
            const environmentId = data.environmentId; // xxx
            const queryString = data.queryString; // e.g. ?depth=1&elements=xElement
            const queryParameters = data.queryParameters; // array with query parameters parameters
            const queryConfig = data.queryConfig; // query configuration
            return `http://my-proxy.io${action}${queryString}`; // proxy URL with omitted project Id
        }
    }
});

import { DeliveryError } from '@kontent-ai/delivery-sdk';

try {
    await deliveryClient.item('invalid_codename').toPromise();
} catch (error) {
    if (error instanceof DeliveryError) {
        // delivery specific error (e.g. item with codename not found...)
        console.log(err.message, err.errorCode);
    } else {
        // some other error
        console.log(error);
    }
}

const result = await deliveryClient.item<Movie>('codename').toPromise();
const json = result.response.data;

// approach #1
const remappedData = deliveryClient.mappingService.viewContentItemResponse<Movie>(json);

// approach #2
const remappedData = deliveryClient.item<Movie>(movieCodename).map(json);

const client = getTestDeliveryClient({
    environmentId: '<YOUR_ENVIRONMENT_ID>',
    linkedItemsReferenceHandler: 'ignore' // or 'map'
});

const deliveryClient = createDeliveryClient({
    environmentId: '<YOUR_ENVIRONMENT_ID>',
    httpService: YourHttpServiceImplementation
});

const deliveryResponse = await createDeliveryClient({ environmentId: 'environmentId' })
    .item('itemCodename')
    .toPromise();
const rawResponseData = deliveryResponse.response; // contains raw response data, headers, status etc..
const responseHeaders = deliveryResponse.response.headers;

const queryText = deliveryClient
    .items()
    .type('movie')
    .limitParameter(10)
    .orderParameter('system.codename', 'desc')
    .getUrl();

console.log(queryText);
// outputs:
// https://deliver.kontent.ai/b52fa0db-84ec-4310-8f7c-3b94ed06644d/items?limit=10&order=system.codename[desc]&system.type=movie