@missioncontrolio/client 0.0.10 → 0.0.12

package/dist/client/generatedAssets/assetPack/item/item/item/index.js

@@ -0,0 +1,14 @@
+import { createAssetPackDetailFromDiscriminatorValue, createProblemDetailsFromDiscriminatorValue } from '../../../../models/index.js';
+export const WithAssetPackItemRequestBuilderUriTemplate = "{+baseurl}/AssetPack/{publisherId}/{productId}/{assetPackId}";
+export const WithAssetPackItemRequestBuilderRequestsMetadata = {
+    get: {
+        uriTemplate: WithAssetPackItemRequestBuilderUriTemplate,
+        responseBodyContentType: "application/json, text/plain;q=0.9",
+        errorMappings: {
+            400: createProblemDetailsFromDiscriminatorValue,
+            500: createProblemDetailsFromDiscriminatorValue,
+        },
+        adapterMethodName: "send",
+        responseBodyFactory: createAssetPackDetailFromDiscriminatorValue,
+    },
+};

package/dist/client/generatedAssets/assetsClient.d.ts

@@ -0,0 +1,8 @@
+import { type AssetPackRequestBuilder } from './assetPack/index.js';
+import { type BaseRequestBuilder, type KeysToExcludeForNavigationMetadata, type NavigationMetadata, type RequestAdapter } from '@microsoft/kiota-abstractions';
+export interface AssetsClient extends BaseRequestBuilder<AssetsClient> {
+    get assetPack(): AssetPackRequestBuilder;
+}
+export declare function createAssetsClient(requestAdapter: RequestAdapter): AssetsClient;
+export declare const AssetsClientUriTemplate = "{+baseurl}";
+export declare const AssetsClientNavigationMetadata: Record<Exclude<keyof AssetsClient, KeysToExcludeForNavigationMetadata>, NavigationMetadata>;

package/dist/client/generatedAssets/assetsClient.js

@@ -0,0 +1,38 @@
+import { AssetPackRequestBuilderNavigationMetadata } from './assetPack/index.js';
+import { apiClientProxifier } from '@microsoft/kiota-abstractions';
+import { FormParseNodeFactory, FormSerializationWriterFactory } from '@microsoft/kiota-serialization-form';
+import { JsonParseNodeFactory, JsonSerializationWriterFactory } from '@microsoft/kiota-serialization-json';
+import { MultipartSerializationWriterFactory } from '@microsoft/kiota-serialization-multipart';
+import { TextParseNodeFactory, TextSerializationWriterFactory } from '@microsoft/kiota-serialization-text';
+export function createAssetsClient(requestAdapter) {
+    if (requestAdapter === undefined) {
+        throw new Error("requestAdapter cannot be undefined");
+    }
+    const serializationWriterFactory = requestAdapter.getSerializationWriterFactory();
+    const parseNodeFactoryRegistry = requestAdapter.getParseNodeFactory();
+    const backingStoreFactory = requestAdapter.getBackingStoreFactory();
+    if (parseNodeFactoryRegistry.registerDefaultDeserializer) {
+        parseNodeFactoryRegistry.registerDefaultDeserializer(JsonParseNodeFactory, backingStoreFactory);
+        parseNodeFactoryRegistry.registerDefaultDeserializer(TextParseNodeFactory, backingStoreFactory);
+        parseNodeFactoryRegistry.registerDefaultDeserializer(FormParseNodeFactory, backingStoreFactory);
+    }
+    if (serializationWriterFactory.registerDefaultSerializer) {
+        serializationWriterFactory.registerDefaultSerializer(JsonSerializationWriterFactory);
+        serializationWriterFactory.registerDefaultSerializer(TextSerializationWriterFactory);
+        serializationWriterFactory.registerDefaultSerializer(FormSerializationWriterFactory);
+        serializationWriterFactory.registerDefaultSerializer(MultipartSerializationWriterFactory);
+    }
+    if (requestAdapter.baseUrl === undefined || requestAdapter.baseUrl === null || requestAdapter.baseUrl === "") {
+        requestAdapter.baseUrl = "https://api.missioncontrol.io/assets/partnerApi/v1";
+    }
+    const pathParameters = {
+        "baseurl": requestAdapter.baseUrl,
+    };
+    return apiClientProxifier(requestAdapter, pathParameters, AssetsClientNavigationMetadata, undefined);
+}
+export const AssetsClientUriTemplate = "{+baseurl}";
+export const AssetsClientNavigationMetadata = {
+    assetPack: {
+        navigationMetadata: AssetPackRequestBuilderNavigationMetadata,
+    },
+};

package/dist/client/generatedAssets/models/index.d.ts

@@ -0,0 +1,54 @@
+import { type AdditionalDataHolder, type ApiError, type Guid, type Parsable, type ParseNode, type SerializationWriter } from '@microsoft/kiota-abstractions';
+export interface Asset extends Parsable {
+    embargo?: Date | null;
+    fileName?: string | null;
+    folder?: string | null;
+    height?: number | null;
+    lastModified?: Date | null;
+    url?: string | null;
+    width?: number | null;
+}
+export interface AssetPack extends Parsable {
+    countryCodes?: string[] | null;
+    id?: string | null;
+    lastModified?: Date | null;
+    name?: string | null;
+    productId?: Guid | null;
+    productName?: string | null;
+}
+export interface AssetPackDetail extends Parsable {
+    assets?: Asset[] | null;
+    countryCodes?: string[] | null;
+    id?: string | null;
+    lastModified?: Date | null;
+    name?: string | null;
+    productId?: Guid | null;
+    productName?: string | null;
+}
+export interface AssetPackListResult extends Parsable {
+    pageCount?: number | null;
+    result?: AssetPack[] | null;
+    totalCount?: number | null;
+}
+export declare function createAssetFromDiscriminatorValue(parseNode: ParseNode | undefined): ((instance?: Parsable) => Record<string, (node: ParseNode) => void>);
+export declare function createAssetPackDetailFromDiscriminatorValue(parseNode: ParseNode | undefined): ((instance?: Parsable) => Record<string, (node: ParseNode) => void>);
+export declare function createAssetPackFromDiscriminatorValue(parseNode: ParseNode | undefined): ((instance?: Parsable) => Record<string, (node: ParseNode) => void>);
+export declare function createAssetPackListResultFromDiscriminatorValue(parseNode: ParseNode | undefined): ((instance?: Parsable) => Record<string, (node: ParseNode) => void>);
+export declare function createProblemDetailsFromDiscriminatorValue(parseNode: ParseNode | undefined): ((instance?: Parsable) => Record<string, (node: ParseNode) => void>);
+export declare function deserializeIntoAsset(asset?: Partial<Asset> | undefined): Record<string, (node: ParseNode) => void>;
+export declare function deserializeIntoAssetPack(assetPack?: Partial<AssetPack> | undefined): Record<string, (node: ParseNode) => void>;
+export declare function deserializeIntoAssetPackDetail(assetPackDetail?: Partial<AssetPackDetail> | undefined): Record<string, (node: ParseNode) => void>;
+export declare function deserializeIntoAssetPackListResult(assetPackListResult?: Partial<AssetPackListResult> | undefined): Record<string, (node: ParseNode) => void>;
+export declare function deserializeIntoProblemDetails(problemDetails?: Partial<ProblemDetails> | undefined): Record<string, (node: ParseNode) => void>;
+export interface ProblemDetails extends AdditionalDataHolder, ApiError, Parsable {
+    detail?: string | null;
+    instance?: string | null;
+    status?: number | null;
+    title?: string | null;
+    type?: string | null;
+}
+export declare function serializeAsset(writer: SerializationWriter, asset?: Partial<Asset> | undefined | null, isSerializingDerivedType?: boolean): void;
+export declare function serializeAssetPack(writer: SerializationWriter, assetPack?: Partial<AssetPack> | undefined | null, isSerializingDerivedType?: boolean): void;
+export declare function serializeAssetPackDetail(writer: SerializationWriter, assetPackDetail?: Partial<AssetPackDetail> | undefined | null, isSerializingDerivedType?: boolean): void;
+export declare function serializeAssetPackListResult(writer: SerializationWriter, assetPackListResult?: Partial<AssetPackListResult> | undefined | null, isSerializingDerivedType?: boolean): void;
+export declare function serializeProblemDetails(writer: SerializationWriter, problemDetails?: Partial<ProblemDetails> | undefined | null, isSerializingDerivedType?: boolean): void;

package/dist/client/generatedAssets/models/index.js

@@ -0,0 +1,117 @@
+export function createAssetFromDiscriminatorValue(parseNode) {
+    return deserializeIntoAsset;
+}
+export function createAssetPackDetailFromDiscriminatorValue(parseNode) {
+    return deserializeIntoAssetPackDetail;
+}
+export function createAssetPackFromDiscriminatorValue(parseNode) {
+    return deserializeIntoAssetPack;
+}
+export function createAssetPackListResultFromDiscriminatorValue(parseNode) {
+    return deserializeIntoAssetPackListResult;
+}
+export function createProblemDetailsFromDiscriminatorValue(parseNode) {
+    return deserializeIntoProblemDetails;
+}
+export function deserializeIntoAsset(asset = {}) {
+    return {
+        "embargo": n => { asset.embargo = n.getDateValue(); },
+        "fileName": n => { asset.fileName = n.getStringValue(); },
+        "folder": n => { asset.folder = n.getStringValue(); },
+        "height": n => { asset.height = n.getNumberValue(); },
+        "lastModified": n => { asset.lastModified = n.getDateValue(); },
+        "url": n => { asset.url = n.getStringValue(); },
+        "width": n => { asset.width = n.getNumberValue(); },
+    };
+}
+export function deserializeIntoAssetPack(assetPack = {}) {
+    return {
+        "countryCodes": n => { assetPack.countryCodes = n.getCollectionOfPrimitiveValues("string"); },
+        "id": n => { assetPack.id = n.getStringValue(); },
+        "lastModified": n => { assetPack.lastModified = n.getDateValue(); },
+        "name": n => { assetPack.name = n.getStringValue(); },
+        "productId": n => { assetPack.productId = n.getGuidValue(); },
+        "productName": n => { assetPack.productName = n.getStringValue(); },
+    };
+}
+export function deserializeIntoAssetPackDetail(assetPackDetail = {}) {
+    return {
+        "assets": n => { assetPackDetail.assets = n.getCollectionOfObjectValues(createAssetFromDiscriminatorValue); },
+        "countryCodes": n => { assetPackDetail.countryCodes = n.getCollectionOfPrimitiveValues("string"); },
+        "id": n => { assetPackDetail.id = n.getStringValue(); },
+        "lastModified": n => { assetPackDetail.lastModified = n.getDateValue(); },
+        "name": n => { assetPackDetail.name = n.getStringValue(); },
+        "productId": n => { assetPackDetail.productId = n.getGuidValue(); },
+        "productName": n => { assetPackDetail.productName = n.getStringValue(); },
+    };
+}
+export function deserializeIntoAssetPackListResult(assetPackListResult = {}) {
+    return {
+        "pageCount": n => { assetPackListResult.pageCount = n.getNumberValue(); },
+        "result": n => { assetPackListResult.result = n.getCollectionOfObjectValues(createAssetPackFromDiscriminatorValue); },
+        "totalCount": n => { assetPackListResult.totalCount = n.getNumberValue(); },
+    };
+}
+export function deserializeIntoProblemDetails(problemDetails = {}) {
+    return {
+        "detail": n => { problemDetails.detail = n.getStringValue(); },
+        "instance": n => { problemDetails.instance = n.getStringValue(); },
+        "status": n => { problemDetails.status = n.getNumberValue(); },
+        "title": n => { problemDetails.title = n.getStringValue(); },
+        "type": n => { problemDetails.type = n.getStringValue(); },
+    };
+}
+export function serializeAsset(writer, asset = {}, isSerializingDerivedType = false) {
+    if (!asset || isSerializingDerivedType) {
+        return;
+    }
+    writer.writeDateValue("embargo", asset.embargo);
+    writer.writeStringValue("fileName", asset.fileName);
+    writer.writeStringValue("folder", asset.folder);
+    writer.writeNumberValue("height", asset.height);
+    writer.writeDateValue("lastModified", asset.lastModified);
+    writer.writeStringValue("url", asset.url);
+    writer.writeNumberValue("width", asset.width);
+}
+export function serializeAssetPack(writer, assetPack = {}, isSerializingDerivedType = false) {
+    if (!assetPack || isSerializingDerivedType) {
+        return;
+    }
+    writer.writeCollectionOfPrimitiveValues("countryCodes", assetPack.countryCodes);
+    writer.writeStringValue("id", assetPack.id);
+    writer.writeDateValue("lastModified", assetPack.lastModified);
+    writer.writeStringValue("name", assetPack.name);
+    writer.writeGuidValue("productId", assetPack.productId);
+    writer.writeStringValue("productName", assetPack.productName);
+}
+export function serializeAssetPackDetail(writer, assetPackDetail = {}, isSerializingDerivedType = false) {
+    if (!assetPackDetail || isSerializingDerivedType) {
+        return;
+    }
+    writer.writeCollectionOfObjectValues("assets", assetPackDetail.assets, serializeAsset);
+    writer.writeCollectionOfPrimitiveValues("countryCodes", assetPackDetail.countryCodes);
+    writer.writeStringValue("id", assetPackDetail.id);
+    writer.writeDateValue("lastModified", assetPackDetail.lastModified);
+    writer.writeStringValue("name", assetPackDetail.name);
+    writer.writeGuidValue("productId", assetPackDetail.productId);
+    writer.writeStringValue("productName", assetPackDetail.productName);
+}
+export function serializeAssetPackListResult(writer, assetPackListResult = {}, isSerializingDerivedType = false) {
+    if (!assetPackListResult || isSerializingDerivedType) {
+        return;
+    }
+    writer.writeNumberValue("pageCount", assetPackListResult.pageCount);
+    writer.writeCollectionOfObjectValues("result", assetPackListResult.result, serializeAssetPack);
+    writer.writeNumberValue("totalCount", assetPackListResult.totalCount);
+}
+export function serializeProblemDetails(writer, problemDetails = {}, isSerializingDerivedType = false) {
+    if (!problemDetails || isSerializingDerivedType) {
+        return;
+    }
+    writer.writeStringValue("detail", problemDetails.detail);
+    writer.writeStringValue("instance", problemDetails.instance);
+    writer.writeNumberValue("status", problemDetails.status);
+    writer.writeStringValue("title", problemDetails.title);
+    writer.writeStringValue("type", problemDetails.type);
+    writer.writeAdditionalData(problemDetails.additionalData);
+}

package/dist/client/missionControlEnvironment.d.ts

@@ -3,4 +3,5 @@ export declare enum MissionControlEnvironment {
     Production = "Production"
 }
 export declare function getBaseUrl(env: MissionControlEnvironment): string;
+export declare function getAssetsBaseUrl(env: MissionControlEnvironment): string;
 export declare function getScope(env: MissionControlEnvironment): string;

package/dist/client/missionControlEnvironment.js

@@ -6,16 +6,21 @@ export var MissionControlEnvironment;
 const settings = {
     [MissionControlEnvironment.Sandbox]: {
         baseUrl: "https://api.sandbox.missioncontrol.io/partnerApi/v2",
+        assetsBaseUrl: "https://api.sandbox.missioncontrol.io/assets/partnerApi/v1",
         scope: "api://38fbfaea-5648-4b51-ac09-d5d90117beff/.default",
     },
     [MissionControlEnvironment.Production]: {
         baseUrl: "https://api.missioncontrol.io/partnerApi/v2",
+        assetsBaseUrl: "https://api.missioncontrol.io/assets/partnerApi/v1",
         scope: "api://1b6f40bc-e051-4b7e-987f-47a4a19fa5ef/.default",
     },
 };
 export function getBaseUrl(env) {
     return settings[env].baseUrl;
 }
+export function getAssetsBaseUrl(env) {
+    return settings[env].assetsBaseUrl;
+}
 export function getScope(env) {
     return settings[env].scope;
 }

package/dist/index.d.ts

@@ -1,5 +1,7 @@
-export { ClientBuilder } from "./client/clientBuilder.js";
-export { MissionControlEnvironment, getBaseUrl, getScope, } from "./client/missionControlEnvironment.js";
+export { ClientBuilder, type MissionControlClient } from "./client/clientBuilder.js";
+export { MissionControlEnvironment, getAssetsBaseUrl, getBaseUrl, getScope, } from "./client/missionControlEnvironment.js";
 export type { Client } from "./client/generated/client.js";
 export { createClient } from "./client/generated/client.js";
 export type * from "./client/generated/models/index.js";
+export type { AssetsClient } from "./client/generatedAssets/assetsClient.js";
+export type { Asset, AssetPack, AssetPackDetail, AssetPackListResult, } from "./client/generatedAssets/models/index.js";

package/dist/index.js

@@ -1,3 +1,3 @@
 export { ClientBuilder } from "./client/clientBuilder.js";
-export { MissionControlEnvironment, getBaseUrl, getScope, } from "./client/missionControlEnvironment.js";
+export { MissionControlEnvironment, getAssetsBaseUrl, getBaseUrl, getScope, } from "./client/missionControlEnvironment.js";
 export { createClient } from "./client/generated/client.js";

package/package.json

@@ -35,5 +35,5 @@
     "@microsoft/kiota-authentication-azure": "^1.0.0-preview.103",
     "@microsoft/kiota-bundle": "^1.0.0-preview.103"
   },
-  "version": "0.0.10"
+  "version": "0.0.12"
 }