@devkong/cli 0.0.1

package/packages/kong-ts/src/lib/cloudEvent.d.ts

@@ -0,0 +1,28 @@
+import { Timezone } from "./timezone";
+export interface CloudEventV1<T = unknown> {
+    [key: string]: unknown;
+    id: string;
+    specversion: string;
+    source: string;
+    type: string;
+    datacontenttype?: string;
+    dataschema?: string;
+    subject?: string;
+    time?: string;
+    data?: T;
+    data_base64?: string;
+}
+export declare class CloudEvent<T = unknown> implements CloudEventV1<T> {
+    [key: string]: unknown;
+    id: string;
+    source: string;
+    type: string;
+    subject?: string;
+    specversion: string;
+    time: string;
+    data?: T;
+    data_base64?: string;
+    datacontenttype?: string;
+    dataschema?: string;
+    constructor(timezone: Timezone, ce: Partial<CloudEvent<T>>);
+}

package/packages/kong-ts/src/lib/color.d.ts

@@ -0,0 +1 @@
+export declare function textToColor(text: string): string;

package/packages/kong-ts/src/lib/compare.d.ts

@@ -0,0 +1,5 @@
+import { Optional } from "./types";
+export declare function shadowEquals<T>(a: T, b: T): boolean;
+export declare function deepEquals<T>(a: T, b: T): boolean;
+export declare function prepareTextForComparison(text: string): string;
+export declare function sameText(a: Optional<string>, b: Optional<string>): boolean;

package/packages/kong-ts/src/lib/duration.d.ts

@@ -0,0 +1,3 @@
+import { Distinct } from "./types";
+export type Duration8601 = Distinct<string, "Duration8601">;
+export declare function isDuration(value: string): value is Duration8601;

package/packages/kong-ts/src/lib/entity.d.ts

@@ -0,0 +1,4 @@
+import { GUID, JsonObject, ShortUUID } from "@kong/ts";
+export type Entity = {
+    id: number | GUID | ShortUUID;
+} & JsonObject;

package/packages/kong-ts/src/lib/error.d.ts

@@ -0,0 +1,7 @@
+export declare class AppError extends Error {
+}
+export declare class DataError<T> extends Error {
+    data: T;
+    constructor(message: string, data: T);
+}
+export declare function errorToPrettyString(error: Error): string;

package/packages/kong-ts/src/lib/guard.d.ts

@@ -0,0 +1,5 @@
+export declare function notNull<T>(value: T | undefined | null): NonNullable<T>;
+export declare function nonRecursiveCall<Args extends unknown[], R>(fn: (...args: Args) => R): (...args: Args) => R;
+export declare function notBlank(value: string): void;
+export declare function nonNegative(value: number): void;
+export declare function ensureIsDuration(value: string): void;

package/packages/kong-ts/src/lib/id.d.ts

@@ -0,0 +1,12 @@
+import { Distinct } from "./types";
+export type GUID = Distinct<string, "GUID">;
+export type CompactUUID32 = Distinct<string, "CompactUUID32">;
+export type CompactUUID16 = Distinct<string, "CompactUUID16">;
+export type CompactUUID8 = Distinct<string, "CompactUUID8">;
+export type ShortUUID = Distinct<string, "ShortUUID">;
+export declare function guid(): GUID;
+export declare function uuidc32(): CompactUUID32;
+export declare function uuidc16(): CompactUUID16;
+export declare function uuidc8(): CompactUUID8;
+export declare function stableUUID<T extends string>(based: T): T;
+export declare function uuidStableSequence<T extends string>(based: T): () => T;

package/packages/kong-ts/src/lib/interval.d.ts

@@ -0,0 +1 @@
+export declare function intervalToString(from: Date, to: Date): string;

package/packages/kong-ts/src/lib/jq.d.ts

@@ -0,0 +1,23 @@
+import { Distinct, Primitive } from "./types";
+export type JqFilter = Distinct<Primitive, "JqExpression">;
+export type JqText = Distinct<string, "JqText">;
+export interface JqObject {
+    [key: string]: Primitive | JqText | JqObject | Array<JqObject> | null;
+}
+export type JqArray = Array<Primitive | JqText | JqObject | JqArray>;
+export type RefactorReplacement = [RegExp, string];
+export interface JqSerializer<T = JqObject | JqArray> {
+    serialize(value: T): JqFilter;
+}
+export declare function jqFilter(value: Primitive): JqFilter;
+export declare function jqText(value: string): JqText;
+export declare function convertToJqFilter(value: JqText): JqFilter;
+export declare function applyJqFilterReplacements(value: JqFilter, replacements: RefactorReplacement[]): JqFilter;
+export declare function applyJqObjectReplacements(obj: JqObject, replacements: RefactorReplacement[]): JqObject;
+export declare function applyJqTextReplacements(text: JqText, replacements: RefactorReplacement[]): JqText;
+export declare class JqObjectSerializer implements JqSerializer {
+    serialize(obj: JqObject | JqArray): JqFilter;
+    private convert;
+}
+export declare function extractJqTextContent(text: JqText): string;
+export declare function wrapWithJqTextMarkers(content: string): JqText;

package/packages/kong-ts/src/lib/json.d.ts

@@ -0,0 +1,11 @@
+import { Distinct, Optional, Result } from "./types";
+export type JsonObject = Record<string, any>;
+export type JsonArray = Array<unknown>;
+export type JsonText = Distinct<string, "JsonText">;
+export type JsonSchemaUrl = Distinct<string, "JsonSchemaUrl">;
+export declare function safeJsonParse<T = any>(text: string): Result<{
+    result: T;
+}>;
+export declare function generateFakeJsonObject(schemaObject: JsonObject): Optional<JsonObject>;
+export declare function prettyJson(value: Optional<JsonObject | JsonArray>): JsonText;
+export declare function jsonToHumanReadable(value: Optional<JsonObject | JsonArray>): string;

package/packages/kong-ts/src/lib/keyGenerator.d.ts

@@ -0,0 +1,6 @@
+export declare class KeyGenerator {
+    private existingKeys;
+    constructor(existingKeys: string[]);
+    next(baseName: string, separator?: string): string;
+    private toAlphabetic;
+}

package/packages/kong-ts/src/lib/list.d.ts

@@ -0,0 +1,3 @@
+export declare function insertItem<T>(list: ReadonlyArray<T>, item: T, index: number): T[];
+export declare function moveItem<T>(list: ReadonlyArray<T>, from: number, to: number): T[];
+export declare function unique<T>(list: T[]): T[];

package/packages/kong-ts/src/lib/merge.d.ts

@@ -0,0 +1,19 @@
+import { JsonObject, Optional } from "@kong/ts";
+import { deepmerge } from "deepmerge-ts";
+export interface Replacement {
+    [key: string]: true | Replacement;
+}
+export declare const deepMerge: <Ts extends readonly unknown[]>(...objects: Ts) => import("deepmerge-ts").DeepMergeHKT<Ts, Readonly<{
+    DeepMergeRecordsURI: "DeepMergeRecordsDefaultURI";
+    DeepMergeArraysURI: "DeepMergeArraysDefaultURI";
+    DeepMergeSetsURI: "DeepMergeSetsDefaultURI";
+    DeepMergeMapsURI: "DeepMergeMapsDefaultURI";
+    DeepMergeOthersURI: "DeepMergeLeafURI";
+    DeepMergeFilterValuesURI: "DeepMergeFilterValuesDefaultURI";
+}>, Readonly<{
+    key: PropertyKey;
+    parents: ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>;
+}>>;
+export declare const deepMergeAll: typeof deepmerge;
+export declare function replaceLeafNodesWithTrue(record: JsonObject): Replacement | true;
+export declare function deletePropertiesBasedOnReplacement(record: JsonObject, replacement: Replacement | true): Optional<JsonObject>;

package/packages/kong-ts/src/lib/normalize.d.ts

@@ -0,0 +1 @@
+export declare function deepDeleteKeys(a: unknown, keysToDelete: string[]): void;

package/packages/kong-ts/src/lib/retry.d.ts

@@ -0,0 +1,8 @@
+import { Action } from "./types";
+interface Retry<T> {
+    fn: () => T;
+    fallback: Action;
+    maxAttempts: number;
+}
+export declare function retry<T = void>({ fn, fallback, maxAttempts }: Retry<T>): T;
+export {};

package/packages/kong-ts/src/lib/telemetry.d.ts

@@ -0,0 +1,8 @@
+import { CompactUUID16, CompactUUID32 } from "@kong/ts";
+export interface RequestId {
+    traceId: CompactUUID32;
+    spanId: CompactUUID16;
+    tags: string[];
+}
+export declare function newRequestId(tags?: string[]): RequestId;
+export declare function fromRequestId(source: RequestId, tags?: string[]): RequestId;

package/packages/kong-ts/src/lib/text.d.ts

@@ -0,0 +1,18 @@
+export declare function trim(text: string): string;
+export interface TextBlock {
+    label: string;
+    lines: string[];
+}
+export declare function splitToBlocks(text: string, separator: RegExp, map?: (item: string) => string): TextBlock[];
+export declare function trimSlashes(text: string): string;
+export declare function replaceFirstOccurrence(text: string, search: string, replacement: string): string;
+export declare function escapeRegex(text: string): string;
+export declare function quote(text: string): string;
+export declare function hashString(text: string): number;
+export declare function removeOuterQuotes(text: string): string;
+export declare function words(text: string, pattern?: RegExp | string): string[];
+export declare function upperFirst(text: string): string;
+export declare function camelize(text: string): string;
+export declare function escapeQuotes(text: string): string;
+export declare function escapeLikeText(text: string): string;
+export declare function byteCount(text: string): number;

package/packages/kong-ts/src/lib/textReader.d.ts

@@ -0,0 +1,8 @@
+import { Optional } from "./types";
+export declare class TextReader {
+    private text;
+    private cursor;
+    constructor(text: string);
+    read(): Optional<string>;
+    peek(): Optional<string>;
+}

package/packages/kong-ts/src/lib/timezone.d.ts

@@ -0,0 +1,5 @@
+import { Distinct } from "./types";
+export type Timezone = Distinct<string, "timezone">;
+export declare const UTC: Timezone;
+export declare const DEFAULT_TIMEZONE: Timezone;
+export declare function getTimezoneList(): Promise<Timezone[]>;

package/packages/kong-ts/src/lib/types.d.ts

@@ -0,0 +1,45 @@
+import { GUID, ShortUUID } from "./id";
+import { Timezone } from "./timezone";
+import { UrlText } from "./url";
+import { IsoDate, IsoTime, UtcDateTime } from "./utc";
+export type Primitive = boolean | GUID | IsoDate | IsoTime | number | ShortUUID | string | Timezone | UrlText | UtcDateTime;
+export interface Pair<T> {
+    key: string;
+    value: T;
+}
+export type Action = () => void;
+export type Distinct<BasedOn, NewTypeNme> = BasedOn & {
+    __TYPE__: [
+        NewTypeNme,
+        ...(BasedOn extends {
+            __TYPE__: infer T;
+        } ? (T extends any[] ? T : []) : [])
+    ];
+};
+export type Loading = "idle" | "pending" | "succeeded" | "failed";
+export type Optional<T> = T | undefined;
+export type RequiredProperties<T> = {
+    [P in keyof T]-?: RequiredProperties<NonNullable<T[P]>>;
+};
+export type Result<T> = (T & {
+    ok: true;
+}) | {
+    ok: false;
+    error: Optional<Error>;
+};
+export type StringKeys<T> = Extract<keyof T, string>;
+export type JsonObject = Record<string, any>;
+export type UnArray<T> = T extends (infer U)[] ? U : never;
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+export type ValidateKeys<K, T extends keyof T extends K ? (K extends keyof T ? unknown : never) : never> = T;
+export type PropertyPath<T> = StringKeys<T> | ".[]" | `.[${number}]` | `${string}.${string}` | `${string}.${string}.${string}` | `${string}.${string}.${string}.${string}`;
+export type PropertyPathMap<T, V> = {
+    [key in PropertyPath<T>]?: V;
+};
+type NonFunctionKeys<T> = {
+    [K in keyof T]: T[K] extends Function ? never : K;
+}[keyof T];
+export type NonFunctionProperties<T> = Pick<T, NonFunctionKeys<T>>;
+export {};

package/packages/kong-ts/src/lib/url.d.ts

@@ -0,0 +1,4 @@
+import { Distinct } from "./types";
+export type UrlText = Distinct<string, "UrlText">;
+export declare function urlText(value: string): UrlText;
+export declare function joinUrlAndPath(baseUrl: UrlText, ...pathSegments: Array<string | number>): UrlText;

package/packages/kong-ts/src/lib/user.d.ts

@@ -0,0 +1,3 @@
+export interface User {
+    name: string;
+}

package/packages/kong-ts/src/lib/utc.d.ts

@@ -0,0 +1,24 @@
+import { Timezone } from "./timezone";
+import { Distinct, Optional } from "./types";
+export type IsoTime = `${number}:${number}:${number}`;
+export type IsoDate = `${string}-${string}-${string}`;
+export type UtcDateTime = `${IsoDate}T${IsoTime}Z`;
+export type ZonedDateTime = Distinct<Date, "zoned-date-time">;
+export interface UtcRange {
+    start: UtcDateTime;
+    end: Optional<UtcDateTime>;
+    timezone: Timezone;
+}
+export declare function isoTimeToClock(time: IsoTime): [number, number, number];
+export declare function isoTimeToDate(time: IsoTime): Date;
+export declare function dateToIsoTime(date: Date): IsoTime;
+export declare function isoTimeNow(): IsoTime;
+export declare function isoTime(hours: number, minutes: number, seconds: number): IsoTime;
+export declare function zonedDateToUtc(date: ZonedDateTime): UtcDateTime;
+export declare function utcToZonedDate(utc: UtcDateTime, timezone: Timezone): ZonedDateTime;
+export declare function utcToZonedText(utc: UtcDateTime, timezone: Timezone, format?: string): string;
+export declare function dateToUtc(date: Date, timezone: Timezone): UtcDateTime;
+export declare function utcNow(timezone: Timezone): UtcDateTime;
+export declare function utcNowRange(timezone: Timezone): UtcRange;
+export declare function mapUtcToZonedDate(utc: UtcDateTime, timezone: Timezone, select: (inZone: ZonedDateTime) => Date): ZonedDateTime;
+export declare function mapDateToZonedDate(date: Date, timezone: Timezone, select: (inZone: ZonedDateTime) => Date): ZonedDateTime;

package/packages/kong-ts/src/lib/utils.d.ts

@@ -0,0 +1,15 @@
+import { Action, JsonObject, Optional } from "./types";
+export declare function noop(): void;
+export declare function yes(): boolean;
+export declare function no(): boolean;
+export declare function reinterpret<NewT, T = any>(value: T): NewT;
+export declare function isFunction(value: unknown): value is (...args: unknown[]) => unknown;
+export declare function isString(value: unknown): value is string;
+export declare function isNumber(value: unknown): value is number;
+export declare function isEmpty(value: Optional<string>): value is undefined | "";
+export declare function clone<T>(value: T): T;
+export declare function assignDefined<T>(value: Optional<T>, assign: (x: T) => void): void;
+export declare function coalesce<T>(...values: (T | undefined | null)[]): T;
+export declare function safeCall(action: Action): Optional<Error>;
+export declare function getFirstObjectValue<T extends JsonObject>(instance: T): Optional<T[keyof T]>;
+export declare function jitter(bottom: number, up: number): number;

package/packages/kong-ts-contract/src/index.d.ts

@@ -0,0 +1,22 @@
+export type { AppCheckpoint } from "./lib/appCheckpoint";
+export type { AppDocument } from "./lib/appDocument";
+export type { AppDocumentBuild } from "./lib/appDocumentBuild";
+export type { AppDocumentSnapshot } from "./lib/appDocumentSnapshot";
+export type { AppExtension } from "./lib/appExtension";
+export type { AppExtensionAlias } from "./lib/appExtensionAlias";
+export type { AppExtensionAliasDetails } from "./lib/appExtensionAliasDetails";
+export type { AppExtensionAliasUse } from "./lib/appExtensionAliasUse";
+export type { AppExtensionAliasUseDetails } from "./lib/appExtensionAliasUseDetails";
+export type { AppExtensionSnapshot } from "./lib/appExtensionSnapshot";
+export type { AppExtensionSnapshotDetails } from "./lib/appExtensionSnapshotDetails";
+export type { AppPresignedUrl } from "./lib/appPresignedUrl";
+export type { AppProcessAlias } from "./lib/appProcessAlias";
+export type { AppProcessAliasUse } from "./lib/appProcessAliasUse";
+export type { AppProcessInstanceId } from "./lib/appProcessInstanceId";
+export type { AppProcessTest } from "./lib/appProcessTest";
+export type { AppProject } from "./lib/appProject";
+export type { AppTestCase } from "./lib/appTestCase";
+export type { AppTestCaseDetails } from "./lib/appTestCaseDetails";
+export type { AppTestCaseMatchFeature } from "./lib/appTestCaseMatchFeature";
+export type { AppWorkspace } from "./lib/appWorkspace";
+export type { SdkExtensionAlias } from "./lib/sdkExtensionAlias";

package/packages/kong-ts-contract/src/lib/appAlias.d.ts

@@ -0,0 +1,11 @@
+import { Entity, ShortUUID, User, UtcDateTime } from "@kong/ts";
+export interface AppAlias<T> extends Entity {
+    name: string;
+    use: T[];
+    basedOnId: ShortUUID;
+    basedOnName: string;
+    created: UtcDateTime;
+    updated: UtcDateTime;
+    createdBy: User["name"];
+    updatedBy: User["name"];
+}

package/packages/kong-ts-contract/src/lib/appCheckpoint.d.ts

@@ -0,0 +1,11 @@
+import { KongSpecFile } from "@kong/spec";
+import { Entity, User, UtcDateTime } from "@kong/ts";
+import { AppDocument } from "./appDocument";
+export interface AppCheckpoint extends Entity {
+    id: KongSpecFile["checkpoint"]["id"];
+    documentId: AppDocument["id"];
+    type: KongSpecFile["checkpoint"]["type"];
+    notes: string;
+    created: UtcDateTime;
+    createdBy: User["name"];
+}

package/packages/kong-ts-contract/src/lib/appDocument.d.ts

@@ -0,0 +1,14 @@
+import { KongSpecFlow } from "@kong/spec";
+import { Entity, Optional, User, UtcDateTime } from "@kong/ts";
+import { AppCheckpoint } from "./appCheckpoint";
+import { AppProject } from "./appProject";
+export interface AppDocument extends Entity {
+    id: KongSpecFlow["id"];
+    projectId: AppProject["id"];
+    title: string;
+    checkpoint: Optional<AppCheckpoint["id"]>;
+    created: UtcDateTime;
+    updated: UtcDateTime;
+    createdBy: User["name"];
+    updatedBy: User["name"];
+}

package/packages/kong-ts-contract/src/lib/appDocumentBuild.d.ts

@@ -0,0 +1,5 @@
+import { UrlText, UtcDateTime } from "@kong/ts";
+export interface AppDocumentBuild {
+    bundleUrl: UrlText;
+    deadline: UtcDateTime;
+}

package/packages/kong-ts-contract/src/lib/appDocumentSnapshot.d.ts

@@ -0,0 +1,10 @@
+import { User, UtcDateTime } from "@kong/ts";
+import { AppCheckpoint } from "./appCheckpoint";
+import { AppDocument } from "./appDocument";
+import { AppSnapshot } from "./appSnapshot";
+export interface AppDocumentSnapshot extends AppSnapshot {
+    documentId: AppDocument["id"];
+    checkpoint: AppCheckpoint["id"];
+    updated: UtcDateTime;
+    updatedBy: User["name"];
+}

package/packages/kong-ts-contract/src/lib/appExtension.d.ts

@@ -0,0 +1,10 @@
+import { Entity, ShortUUID, User, UtcDateTime } from "@kong/ts";
+export interface AppExtension extends Entity {
+    id: ShortUUID;
+    name: string;
+    deprecated: boolean;
+    created: UtcDateTime;
+    updated: UtcDateTime;
+    createdBy: User["name"];
+    updatedBy: User["name"];
+}

package/packages/kong-ts-contract/src/lib/appExtensionAlias.d.ts

@@ -0,0 +1,3 @@
+import { AppAlias } from "./appAlias";
+import { AppExtensionAliasUse } from "./appExtensionAliasUse";
+export type AppExtensionAlias = AppAlias<AppExtensionAliasUse>;

package/packages/kong-ts-contract/src/lib/appExtensionAliasDetails.d.ts

@@ -0,0 +1,9 @@
+import { KongSpecHowToInvoke } from "@kong/spec";
+import { AppAlias } from "./appAlias";
+import { AppExtensionAliasUse } from "./appExtensionAliasUse";
+import { SdkExtensionAlias } from "./sdkExtensionAlias";
+export interface AppExtensionAliasDetails extends AppAlias<AppExtensionAliasUse> {
+    inputSchema?: NonNullable<SdkExtensionAlias["input"]>["schema"];
+    outputSchema?: NonNullable<SdkExtensionAlias["output"]>["schema"];
+    invoke?: Partial<KongSpecHowToInvoke>;
+}

package/packages/kong-ts-contract/src/lib/appExtensionAliasUse.d.ts

@@ -0,0 +1,5 @@
+import { AppExtensionSnapshot } from "./appExtensionSnapshot";
+export interface AppExtensionAliasUse {
+    snapshot: AppExtensionSnapshot;
+    balance: number;
+}

package/packages/kong-ts-contract/src/lib/appExtensionAliasUseDetails.d.ts

@@ -0,0 +1,10 @@
+import { AppExtensionAliasUse } from "./appExtensionAliasUse";
+import { AppExtensionSnapshotDetails } from "./appExtensionSnapshotDetails";
+import { SdkExtensionAlias } from "./sdkExtensionAlias";
+export interface AppExtensionAliasUseDetails {
+    snapshot: AppExtensionSnapshotDetails;
+    balance: AppExtensionAliasUse["balance"];
+    inputFilter?: NonNullable<SdkExtensionAlias["input"]>["filter"];
+    outputFilter?: NonNullable<SdkExtensionAlias["output"]>["filter"];
+    env?: SdkExtensionAlias["env"];
+}

package/packages/kong-ts-contract/src/lib/appExtensionSnapshot.d.ts

@@ -0,0 +1,2 @@
+import { AppSnapshot } from "./appSnapshot";
+export type AppExtensionSnapshot = AppSnapshot;

package/packages/kong-ts-contract/src/lib/appExtensionSnapshotDetails.d.ts

@@ -0,0 +1,9 @@
+import { JsonObject } from "@kong/ts";
+import { JSONSchema7 } from "json-schema";
+import { AppSnapshot } from "./appSnapshot";
+export interface AppExtensionSnapshotDetails extends AppSnapshot {
+    sdk: string;
+    inputSchema: JSONSchema7;
+    outputSchema: JSONSchema7;
+    metadata: JsonObject;
+}

package/packages/kong-ts-contract/src/lib/appPresignedUrl.d.ts

@@ -0,0 +1,5 @@
+import { Distinct, UrlText } from "@kong/ts";
+export interface AppPresignedUrl {
+    key: Distinct<string, "AppPresignedUrlKey">;
+    url: UrlText;
+}

package/packages/kong-ts-contract/src/lib/appProcessAlias.d.ts

@@ -0,0 +1,3 @@
+import { AppAlias } from "./appAlias";
+import { AppProcessAliasUse } from "./appProcessAliasUse";
+export type AppProcessAlias = AppAlias<AppProcessAliasUse>;

package/packages/kong-ts-contract/src/lib/appProcessAliasUse.d.ts

@@ -0,0 +1,7 @@
+import { AppDocumentSnapshot } from "./appDocumentSnapshot";
+import { AppExtensionSnapshot } from "./appExtensionSnapshot";
+export interface AppProcessAliasUse {
+    snapshotVersion: AppDocumentSnapshot["version"];
+    snapshotSdk: AppExtensionSnapshot["sdk"];
+    balance: number;
+}

package/packages/kong-ts-contract/src/lib/appProcessInstanceId.d.ts

@@ -0,0 +1,2 @@
+import { Distinct, GUID } from "@kong/ts";
+export type AppProcessInstanceId = Distinct<GUID, "AppProcessInstanceId">;

package/packages/kong-ts-contract/src/lib/appProcessTest.d.ts

@@ -0,0 +1,6 @@
+import { JsonObject, UrlText, UtcDateTime } from "@kong/ts";
+export interface AppProcessTest {
+    url: UrlText;
+    payload: JsonObject;
+    deadline: UtcDateTime;
+}

package/packages/kong-ts-contract/src/lib/appProject.d.ts

@@ -0,0 +1,11 @@
+import { Entity, ShortUUID, User, UtcDateTime } from "@kong/ts";
+import { AppWorkspace } from "./appWorkspace";
+export interface AppProject extends Entity {
+    id: ShortUUID;
+    title: string;
+    created: UtcDateTime;
+    updated: UtcDateTime;
+    workspaceId: AppWorkspace["id"];
+    createdBy: User["name"];
+    updatedBy: User["name"];
+}

package/packages/kong-ts-contract/src/lib/appSnapshot.d.ts

@@ -0,0 +1,7 @@
+import { Entity, User, UtcDateTime } from "@kong/ts";
+export interface AppSnapshot extends Entity {
+    version: number;
+    notes: string;
+    created: UtcDateTime;
+    createdBy: User["name"];
+}

package/packages/kong-ts-contract/src/lib/appTestCase.d.ts

@@ -0,0 +1,10 @@
+import { Entity, User, UtcDateTime } from "@kong/ts";
+export interface AppTestCase extends Entity {
+    id: number;
+    title: string;
+    tags: string[];
+    created: UtcDateTime;
+    updated: UtcDateTime;
+    createdBy: User["name"];
+    updatedBy: User["name"];
+}

package/packages/kong-ts-contract/src/lib/appTestCaseDetails.d.ts

@@ -0,0 +1,8 @@
+import { JsonObject } from "@kong/ts";
+import { AppTestCase } from "./appTestCase";
+import { AppTestCaseMatchFeature } from "./appTestCaseMatchFeature";
+export interface AppTestCaseDetails extends AppTestCase {
+    inputPayload: JsonObject;
+    expectedResult: JsonObject;
+    matchFeatures: AppTestCaseMatchFeature;
+}

package/packages/kong-ts-contract/src/lib/appTestCaseMatchFeature.d.ts

@@ -0,0 +1,19 @@
+export declare enum AppTestCaseMatchFeature {
+    DATE_IGNORE_TIME = 1,
+    LIST_ACCEPT_EMPTY_AS_NULL = 2,
+    LIST_ALLOW_DUPLICATES = 4,
+    LIST_IGNORE_NULL_ELEMENTS = 8,
+    LIST_IGNORE_ORDER = 16,
+    NUMBER_ALLOW_NEGATIVE = 32,
+    OBJECT_ACCEPT_EMPTY_AS_NULL = 64,
+    OBJECT_ALLOW_EMPTY = 128,
+    OBJECT_ALLOW_NULLS = 256,
+    OBJECT_ALLOW_EXTRA_KEYS = 512,
+    OBJECT_IGNORE_FIELDS_ORDER = 1024,
+    OBJECT_IGNORE_FIELD_CASE = 2048,
+    OBJECT_IGNORE_MISSING_FIELDS = 4096,
+    TEXT_ACCEPT_EMPTY_AS_NULL = 8192,
+    TEXT_ENABLE_FUZZY_MATCH = 16384,
+    TEXT_IGNORE_CASE = 32768,
+    TEXT_IGNORE_WHITESPACE = 65536
+}

package/packages/kong-ts-contract/src/lib/appWorkspace.d.ts

@@ -0,0 +1,9 @@
+import { Entity, ShortUUID, User, UtcDateTime } from "@kong/ts";
+export interface AppWorkspace extends Entity {
+    id: ShortUUID;
+    title: string;
+    created: UtcDateTime;
+    updated: UtcDateTime;
+    createdBy: User["name"];
+    updatedBy: User["name"];
+}

package/packages/kong-ts-contract/src/lib/sdkExtensionAlias.d.ts

@@ -0,0 +1,18 @@
+import { KongSpecHowToInvoke } from "@kong/spec";
+import { JqFilter, JsonObject } from "@kong/ts";
+import { JSONSchema7 } from "json-schema";
+interface SdkExtensionAliasInput {
+    filter: JqFilter;
+    schema: JSONSchema7;
+}
+interface SdkExtensionAliasOutput {
+    filter: JqFilter;
+    schema: JSONSchema7;
+}
+export interface SdkExtensionAlias {
+    input?: SdkExtensionAliasInput;
+    output?: SdkExtensionAliasOutput;
+    invoke?: KongSpecHowToInvoke;
+    env?: JsonObject;
+}
+export {};