@liquidmetal-ai/drizzle 0.0.1

package/dist/appify/validate.test.js

@@ -0,0 +1,327 @@
+import { expect, test } from 'vitest';
+import { buildManifest } from './build.js';
+import { Parser, Tokenizer } from './parse.js';
+import { validate, VALIDATORS } from './validate.js';
+test('validate nothing', async () => {
+    const manifest = `
+application "my-app" {
+  service "my-service" {}
+  actor "my-actor" {}
+  observer "my-observer" {}
+  bucket "my-bucket" {}
+  queue "my-queue" {}
+}
+`;
+    const tokenizer = new Tokenizer(manifest);
+    const parser = new Parser(tokenizer);
+    const parsedManifest = parser.parse();
+    const [builtApps] = buildManifest(parsedManifest);
+    const validateErrors = await validate(builtApps, VALIDATORS);
+    expect(validateErrors).toEqual([]);
+});
+test('validate bad binds', async () => {
+    const manifest = `
+application "my-app" {
+  service "my-service" {
+    binding {
+      bad_bind = "my-missing-service"
+    }
+}
+`;
+    const tokenizer = new Tokenizer(manifest);
+    const parser = new Parser(tokenizer);
+    const parsedManifest = parser.parse();
+    const [builtApps] = buildManifest(parsedManifest);
+    const validateErrors = await validate(builtApps, VALIDATORS);
+    expect(validateErrors).toMatchObject([
+        {
+            message: 'binding names should be UPPER_SNAKE_CASE',
+            line: 5,
+            column: 7,
+            start: 69,
+            end: 77,
+            severity: 'warning',
+        },
+        {
+            message: 'binding "my-missing-service" not found',
+            line: 5,
+            column: 18,
+            start: 80,
+            end: 100,
+            severity: 'error',
+        },
+    ]);
+});
+test('domainValidator', async () => {
+    const manifest = `
+application "my-app" {
+  service "my-service" {
+    domain {
+      fqdn = "not-valid.com_foo"
+    }
+  }
+}
+`;
+    const tokenizer = new Tokenizer(manifest);
+    const parser = new Parser(tokenizer);
+    const parsedManifest = parser.parse();
+    const [builtApps] = buildManifest(parsedManifest);
+    const validateErrors = await validate(builtApps, VALIDATORS);
+    expect(validateErrors).toMatchObject([
+        {
+            message: 'domain "not-valid.com_foo" is an invalid domain name',
+            line: 5,
+            column: 14,
+            start: 75,
+            end: 94,
+            severity: 'warning',
+        },
+    ]);
+});
+test('visibilityValidator', async () => {
+    const manifest = `
+application "my-app" {
+  service "my-service" {
+    visibility = 'not-a-visibility'
+  }
+}
+`;
+    const tokenizer = new Tokenizer(manifest);
+    const parser = new Parser(tokenizer);
+    const parsedManifest = parser.parse();
+    const [builtApps] = buildManifest(parsedManifest);
+    const validateErrors = await validate(builtApps, VALIDATORS);
+    expect(validateErrors).toMatchObject([
+        {
+            message: 'visibility must be one of none, public, private, protected, application, suite, tenant',
+            line: 4,
+            column: 18,
+            start: 66,
+            end: 84,
+            severity: 'error',
+        },
+    ]);
+});
+test('nameValidator', async () => {
+    const manifest = `
+application "MyApp" {
+  service "my-service" {}
+}
+`;
+    const tokenizer = new Tokenizer(manifest);
+    const parser = new Parser(tokenizer);
+    const parsedManifest = parser.parse();
+    const [builtApps] = buildManifest(parsedManifest);
+    const validateErrors = await validate(builtApps, VALIDATORS);
+    expect(validateErrors).toMatchObject([
+        {
+            message: 'name must be lowercase and dash-separated',
+            line: 2,
+            column: 13,
+            start: 13,
+            end: 20,
+            severity: 'error',
+        },
+    ]);
+});
+test('duplicateModuleValidator', async () => {
+    const manifest = `
+application "my-app" {
+  service "my-service" {}
+
+  service "my-service" {}
+}
+`;
+    const tokenizer = new Tokenizer(manifest);
+    const parser = new Parser(tokenizer);
+    const parsedManifest = parser.parse();
+    const [builtApps] = buildManifest(parsedManifest);
+    const validateErrors = await validate(builtApps, VALIDATORS);
+    expect(validateErrors).toMatchObject([
+        {
+            message: 'module my-service has already been defined',
+            line: 5,
+            column: 11,
+            start: 61,
+            end: 73,
+            severity: 'error',
+        },
+    ]);
+});
+test('validate env var format', async () => {
+    const manifest = `
+application "my-app" {
+  service "my-service" {
+    env "MY_ENV_VAR" {}
+  }
+}
+`;
+    const tokenizer = new Tokenizer(manifest);
+    const parser = new Parser(tokenizer);
+    const parsedManifest = parser.parse();
+    const [builtApps] = buildManifest(parsedManifest);
+    const validateErrors = await validate(builtApps, VALIDATORS);
+    expect(validateErrors).toEqual([]);
+});
+test('validate vector missing parameters', async () => {
+    const manifest = `
+application "my-app" {
+  service "my-service" {}
+  vector_index "my-index" {
+  }
+}
+`;
+    const tokenizer = new Tokenizer(manifest);
+    const parser = new Parser(tokenizer);
+    const parsedManifest = parser.parse();
+    const [builtApps] = buildManifest(parsedManifest);
+    const validateErrors = await validate(builtApps, VALIDATORS);
+    expect(validateErrors).toMatchObject([
+        {
+            message: 'vector index must have a dimension',
+        },
+        {
+            message: 'vector index metric must be either cosine or euclidean',
+        },
+    ]);
+});
+test('validate vector index parameters', async () => {
+    const manifest = `
+application "my-app" {
+  service "my-service" {}
+  vector_index "my-index" {
+    dimension = 128.9
+    metric = "cosine"
+  }
+}
+`;
+    const tokenizer = new Tokenizer(manifest);
+    const parser = new Parser(tokenizer);
+    const parsedManifest = parser.parse();
+    const [builtApps] = buildManifest(parsedManifest);
+    const validateErrors = await validate(builtApps, VALIDATORS);
+    expect(validateErrors).toMatchObject([
+        {
+            message: 'vector index dimension must be an integer',
+        },
+    ]);
+});
+test('observer source validator', async () => {
+    let manifest = `
+application "my-app" {
+  observer "my-observer" {
+    source {
+      service = "my-service"
+    }
+  }
+}
+`;
+    let tokenizer = new Tokenizer(manifest);
+    let parser = new Parser(tokenizer);
+    let parsedManifest = parser.parse();
+    let [builtApps] = buildManifest(parsedManifest);
+    let validateErrors = await validate(builtApps, VALIDATORS);
+    expect(validateErrors).toMatchObject([
+        {
+            message: 'observer source must have either a bucket or a queue',
+        },
+    ]);
+    manifest = `
+application "my-app" {
+  observer "my-observer" {
+    source {
+      bucket = "my-bucket"
+      queue = "my-queue"
+    }
+  }
+}
+`;
+    tokenizer = new Tokenizer(manifest);
+    parser = new Parser(tokenizer);
+    parsedManifest = parser.parse();
+    [builtApps] = buildManifest(parsedManifest);
+    validateErrors = await validate(builtApps, VALIDATORS);
+    expect(validateErrors).toMatchObject([
+        {
+            message: 'observer source can only have one of bucket or queue',
+        },
+        {
+            message: 'bucket "my-bucket" not found',
+        },
+        {
+            message: 'queue "my-queue" not found',
+        },
+    ]);
+    manifest = `
+application "my-app" {
+  observer "my-observer" {
+    source {
+      bucket = "my-bucket"
+    }
+  }
+}
+`;
+    tokenizer = new Tokenizer(manifest);
+    parser = new Parser(tokenizer);
+    parsedManifest = parser.parse();
+    [builtApps] = buildManifest(parsedManifest);
+    validateErrors = await validate(builtApps, VALIDATORS);
+    expect(validateErrors).toMatchObject([
+        {
+            message: 'bucket "my-bucket" not found',
+        },
+    ]);
+    manifest = `
+application "my-app" {
+  observer "my-observer" {
+    source {
+      bucket = "my-bucket"
+    }
+    source {
+      bucket = "my-bucket"
+    }
+  }
+}
+`;
+    tokenizer = new Tokenizer(manifest);
+    parser = new Parser(tokenizer);
+    parsedManifest = parser.parse();
+    [builtApps] = buildManifest(parsedManifest);
+    validateErrors = await validate(builtApps, VALIDATORS);
+    expect(validateErrors).toMatchObject([
+        {
+            message: 'bucket "my-bucket" not found',
+        },
+        {
+            message: 'bucket "my-bucket" not found',
+        },
+        {
+            message: 'source my-bucket is duplicated',
+        },
+    ]);
+    manifest = `
+application "my-app" {
+  queue "my-queue" {}
+  observer "my-observer" {
+    source {
+      queue = "my-queue"
+      rule {
+	actions = ['PutObject']
+	prefix = ''
+	suffix = ''
+      }
+    }
+  }
+}
+`;
+    tokenizer = new Tokenizer(manifest);
+    parser = new Parser(tokenizer);
+    parsedManifest = parser.parse();
+    [builtApps] = buildManifest(parsedManifest);
+    validateErrors = await validate(builtApps, VALIDATORS);
+    expect(validateErrors).toMatchObject([
+        {
+            message: 'queue sources do not have bucket notification rules',
+        },
+    ]);
+});

package/dist/codestore.d.ts

@@ -0,0 +1,34 @@
+export interface CodeStore {
+    [key: string]: Bundle;
+}
+export interface Stat {
+    sizeBytes: number;
+    sha256Hex: string;
+}
+export interface ReadableBundle {
+    list(): Promise<string[]>;
+    read(name: string): Promise<Buffer>;
+    stat(name: string): Promise<Stat>;
+    [Symbol.asyncIterator](): AsyncGenerator<File>;
+    hash(): Promise<string>;
+}
+export interface WritableBundle {
+    write(name: string, content: Buffer): Promise<void>;
+    delete(name: string): Promise<void>;
+}
+export type Bundle = ReadableBundle & WritableBundle;
+export interface File {
+    name: string;
+    read(): Promise<Buffer>;
+    stat(): Promise<Stat>;
+}
+export declare abstract class BundleBase implements ReadableBundle {
+    abstract list(): Promise<string[]>;
+    abstract read(name: string): Promise<Buffer>;
+    stat(name: string): Promise<Stat>;
+    [Symbol.asyncIterator](): AsyncGenerator<File>;
+    hash(): Promise<string>;
+}
+export declare function archive(bundle: ReadableBundle): Promise<ArrayBuffer>;
+export declare function unarchive(zipBuffer: ArrayBuffer, bundle: WritableBundle): Promise<void>;
+//# sourceMappingURL=codestore.d.ts.map

package/dist/codestore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codestore.d.ts","sourceRoot":"","sources":["../src/codestore.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,SAAS;IACxB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,IAAI;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAC1B,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACpC,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClC,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,cAAc,CAAC,IAAI,CAAC,CAAC;IAC/C,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CACzB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACrC;AAED,MAAM,MAAM,MAAM,GAAG,cAAc,GAAG,cAAc,CAAC;AAErD,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IACxB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB;AAED,8BAAsB,UAAW,YAAW,cAAc;IACxD,QAAQ,CAAC,IAAI,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAEtC,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBhC,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,cAAc,CAAC,IAAI,CAAC;IAW/C,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;CAO9B;AAED,wBAAsB,OAAO,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,WAAW,CAAC,CAM1E;AAED,wBAAsB,SAAS,CAAC,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAS7F"}

package/dist/codestore.js

@@ -0,0 +1,54 @@
+import crypto from 'crypto';
+import JSZip from 'jszip';
+export class BundleBase {
+    async stat(name) {
+        const content = await this.read(name);
+        if (content === undefined) {
+            throw new Error(`File not found: ${name}`);
+        }
+        const hash = crypto.createHash('sha256');
+        hash.update(content);
+        const sha256Hex = hash.digest('hex');
+        return {
+            sizeBytes: content.length,
+            sha256Hex,
+        };
+    }
+    // This is an AsyncInterator generator function that returns "File"
+    // objects that can be read or stat'd. Use via:
+    // for await (const file of bundle) { ... }
+    async *[Symbol.asyncIterator]() {
+        const list = await this.list();
+        for (const name of list) {
+            yield {
+                name,
+                read: async () => await this.read(name),
+                stat: async () => await this.stat(name),
+            };
+        }
+    }
+    async hash() {
+        const hash = crypto.createHash('sha256', { encoding: 'hex' });
+        for await (const file of this) {
+            hash.update(await file.read());
+        }
+        return hash.digest('hex');
+    }
+}
+export async function archive(bundle) {
+    const zip = new JSZip();
+    for await (const file of bundle) {
+        zip.file(file.name, await file.read());
+    }
+    return await zip.generateAsync({ type: 'arraybuffer' });
+}
+export async function unarchive(zipBuffer, bundle) {
+    const zip = await JSZip.loadAsync(zipBuffer);
+    for (const [, file] of Object.entries(zip.files)) {
+        if (file.dir) {
+            continue;
+        }
+        const content = await file.async('arraybuffer');
+        await bundle.write(file.name, Buffer.from(content));
+    }
+}

package/dist/codestore.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=codestore.test.d.ts.map

package/dist/codestore.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codestore.test.d.ts","sourceRoot":"","sources":["../src/codestore.test.ts"],"names":[],"mappings":""}

package/dist/codestore.test.js

@@ -0,0 +1,84 @@
+import { expect, test } from 'vitest';
+import { BundleBase, archive, unarchive } from './codestore.js';
+class MemoryBundle extends BundleBase {
+    files = new Map();
+    async list() {
+        return Array.from(this.files.keys());
+    }
+    async read(name) {
+        const buff = this.files.get(name);
+        if (buff === undefined) {
+            throw new Error(`File not found: ${name}`);
+        }
+        return buff;
+    }
+    async write(name, content) {
+        this.files.set(name, content);
+    }
+    async delete(name) {
+        this.files.delete(name);
+    }
+}
+test('archive and unarchive', async () => {
+    const bundle = new MemoryBundle();
+    await bundle.write('file1.txt', Buffer.from('hello'));
+    await bundle.write('file2.txt', Buffer.from('world'));
+    const hash1 = await bundle.hash();
+    const archiveBuffer = await archive(bundle);
+    const bundle2 = new MemoryBundle();
+    await unarchive(archiveBuffer, bundle2);
+    const hash2 = await bundle2.hash();
+    expect(hash1).toBe(hash2);
+    expect(await bundle2.list()).toEqual(['file1.txt', 'file2.txt']);
+    expect((await bundle2.read('file1.txt')).toString()).toBe('hello');
+    expect((await bundle2.read('file2.txt')).toString()).toBe('world');
+});
+test('list bundle with files', async () => {
+    const bundle = new MemoryBundle();
+    await bundle.write('file1.txt', Buffer.from('hello'));
+    await bundle.write('file2.txt', Buffer.from('world'));
+    expect(await bundle.list()).toEqual(['file1.txt', 'file2.txt']);
+});
+test('read file from bundle', async () => {
+    const bundle = new MemoryBundle();
+    await bundle.write('file1.txt', Buffer.from('hello'));
+    expect((await bundle.read('file1.txt')).toString()).toBe('hello');
+});
+test('read missing file from bundle', async () => {
+    const bundle = new MemoryBundle();
+    expect(bundle.read('file1.txt')).rejects.toThrowError('File not found: file1.txt');
+});
+test('delete file from bundle', async () => {
+    const bundle = new MemoryBundle();
+    await bundle.write('file1.txt', Buffer.from('hello'));
+    await bundle.delete('file1.txt');
+    expect(bundle.read('file1.txt')).rejects.toThrowError('File not found: file1.txt');
+});
+test('for await of bundle', async () => {
+    const bundle = new MemoryBundle();
+    await bundle.write('file1.txt', Buffer.from('hello'));
+    await bundle.write('file2.txt', Buffer.from('world'));
+    const files = [];
+    for await (const file of bundle) {
+        files.push(file.name);
+    }
+    expect(files).toEqual(['file1.txt', 'file2.txt']);
+});
+test('stat file from bundle', async () => {
+    const bundle = new MemoryBundle();
+    await bundle.write('file1.txt', Buffer.from('hello'));
+    const stat = await bundle.stat('file1.txt');
+    expect(stat.sizeBytes).toBe(5);
+    expect(stat.sha256Hex).toBe('2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824');
+});
+test('stat missing file from bundle', async () => {
+    const bundle = new MemoryBundle();
+    expect(bundle.stat('file1.txt')).rejects.toThrowError('File not found: file1.txt');
+});
+test('hash bundle', async () => {
+    const bundle = new MemoryBundle();
+    await bundle.write('file1.txt', Buffer.from('hello'));
+    await bundle.write('file2.txt', Buffer.from('world'));
+    const hash = await bundle.hash();
+    expect(hash).toBe('936a185caaa266bb9cbe981e9e05cb78cd732b0b3280eb944412bb6f8f8f07af');
+});

package/dist/liquidmetal/v1alpha1/catalog_connect.d.ts

@@ -0,0 +1,147 @@
+import { ApplicationsRequest, ApplicationsResponse, BootstrapRequest, BootstrapResponse, CreateApplicationsRequest, CreateApplicationsResponse, CreateVersionRequest, CreateVersionResponse, DeleteApplicationsRequest, DeleteApplicationsResponse, GetEnvRequest, GetEnvResponse, QueryResourcesRequest, QueryResourcesResponse, SetApplicationActiveStatesRequest, SetApplicationActiveStatesResponse, SetEnvRequest, SetEnvResponse, StatBundleRequest, StatBundleResponse, UploadBundleRequest, UploadBundleResponse, VersionsRequest, VersionsResponse } from "./catalog_pb.js";
+import { MethodKind } from "@bufbuild/protobuf";
+/**
+ * CatalogService defines data interactions for the catalog portion of the
+ * rainbow UI.
+ *
+ * As an authorization style choice, the RPCs are focused on providing user
+ * context data explicitly (don't assume the userId or orgId from the
+ * authentication header.) It is expected that an authorization layer will
+ * enforce the ability for a request to act as a specified user or org matching
+ * against the authentication header. This makes services easier to mock without
+ * needing to think about injecting mock authentication contexts and allows for
+ * use cases where certain roles of users may wish to act as other users.
+ *
+ * @generated from service liquidmetal.v1alpha1.CatalogService
+ */
+export declare const CatalogService: {
+    readonly typeName: "liquidmetal.v1alpha1.CatalogService";
+    readonly methods: {
+        /**
+         * @generated from rpc liquidmetal.v1alpha1.CatalogService.Versions
+         */
+        readonly versions: {
+            readonly name: "Versions";
+            readonly I: typeof VersionsRequest;
+            readonly O: typeof VersionsResponse;
+            readonly kind: MethodKind.Unary;
+        };
+        /**
+         * @generated from rpc liquidmetal.v1alpha1.CatalogService.CreateVersion
+         */
+        readonly createVersion: {
+            readonly name: "CreateVersion";
+            readonly I: typeof CreateVersionRequest;
+            readonly O: typeof CreateVersionResponse;
+            readonly kind: MethodKind.Unary;
+        };
+        /**
+         * Applications fetches a list of applications for an organization.
+         * This list follows best practices for pagination.
+         * https://protobuf.dev/programming-guides/api/#define-pagination-api
+         *
+         * @generated from rpc liquidmetal.v1alpha1.CatalogService.Applications
+         */
+        readonly applications: {
+            readonly name: "Applications";
+            readonly I: typeof ApplicationsRequest;
+            readonly O: typeof ApplicationsResponse;
+            readonly kind: MethodKind.Unary;
+        };
+        /**
+         * @generated from rpc liquidmetal.v1alpha1.CatalogService.CreateApplications
+         */
+        readonly createApplications: {
+            readonly name: "CreateApplications";
+            readonly I: typeof CreateApplicationsRequest;
+            readonly O: typeof CreateApplicationsResponse;
+            readonly kind: MethodKind.Unary;
+        };
+        /**
+         * @generated from rpc liquidmetal.v1alpha1.CatalogService.SetApplicationActiveStates
+         */
+        readonly setApplicationActiveStates: {
+            readonly name: "SetApplicationActiveStates";
+            readonly I: typeof SetApplicationActiveStatesRequest;
+            readonly O: typeof SetApplicationActiveStatesResponse;
+            readonly kind: MethodKind.Unary;
+        };
+        /**
+         * @generated from rpc liquidmetal.v1alpha1.CatalogService.DeleteApplications
+         */
+        readonly deleteApplications: {
+            readonly name: "DeleteApplications";
+            readonly I: typeof DeleteApplicationsRequest;
+            readonly O: typeof DeleteApplicationsResponse;
+            readonly kind: MethodKind.Unary;
+        };
+        /**
+         * UploadBundle uploads a bundle for a specific application version.
+         *
+         * @generated from rpc liquidmetal.v1alpha1.CatalogService.UploadBundle
+         */
+        readonly uploadBundle: {
+            readonly name: "UploadBundle";
+            readonly I: typeof UploadBundleRequest;
+            readonly O: typeof UploadBundleResponse;
+            readonly kind: MethodKind.Unary;
+        };
+        /**
+         * StatBundle returns the metadata for a bundle.
+         *
+         * @generated from rpc liquidmetal.v1alpha1.CatalogService.StatBundle
+         */
+        readonly statBundle: {
+            readonly name: "StatBundle";
+            readonly I: typeof StatBundleRequest;
+            readonly O: typeof StatBundleResponse;
+            readonly kind: MethodKind.Unary;
+        };
+        /**
+         * SetEnv sets an environment variable for an application/version.
+         *
+         * @generated from rpc liquidmetal.v1alpha1.CatalogService.SetEnv
+         */
+        readonly setEnv: {
+            readonly name: "SetEnv";
+            readonly I: typeof SetEnvRequest;
+            readonly O: typeof SetEnvResponse;
+            readonly kind: MethodKind.Unary;
+        };
+        /**
+         * GetEnv gets an environment variable for an application/version.
+         *
+         * @generated from rpc liquidmetal.v1alpha1.CatalogService.GetEnv
+         */
+        readonly getEnv: {
+            readonly name: "GetEnv";
+            readonly I: typeof GetEnvRequest;
+            readonly O: typeof GetEnvResponse;
+            readonly kind: MethodKind.Unary;
+        };
+        /**
+         * QueryResources returns the physical underlying resources for a given query
+         *
+         * @generated from rpc liquidmetal.v1alpha1.CatalogService.QueryResources
+         */
+        readonly queryResources: {
+            readonly name: "QueryResources";
+            readonly I: typeof QueryResourcesRequest;
+            readonly O: typeof QueryResourcesResponse;
+            readonly kind: MethodKind.Unary;
+        };
+        /**
+         * Bootstrap is a special RPC that is used to bootstrap the system
+         * using a one-time token.
+         *
+         * @generated from rpc liquidmetal.v1alpha1.CatalogService.Bootstrap
+         */
+        readonly bootstrap: {
+            readonly name: "Bootstrap";
+            readonly I: typeof BootstrapRequest;
+            readonly O: typeof BootstrapResponse;
+            readonly kind: MethodKind.Unary;
+        };
+    };
+};
+//# sourceMappingURL=catalog_connect.d.ts.map

package/dist/liquidmetal/v1alpha1/catalog_connect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog_connect.d.ts","sourceRoot":"","sources":["../../../src/liquidmetal/v1alpha1/catalog_connect.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,yBAAyB,EAAE,0BAA0B,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,yBAAyB,EAAE,0BAA0B,EAAE,aAAa,EAAE,cAAc,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,iCAAiC,EAAE,kCAAkC,EAAE,aAAa,EAAE,cAAc,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACrjB,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAEhD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,cAAc;;;QAGvB;;WAEG;;;;;;;QAOH;;WAEG;;;;;;;QAOH;;;;;;WAMG;;;;;;;QAOH;;WAEG;;;;;;;QAOH;;WAEG;;;;;;;QAOH;;WAEG;;;;;;;QAOH;;;;WAIG;;;;;;;QAOH;;;;WAIG;;;;;;;QAOH;;;;WAIG;;;;;;;QAOH;;;;WAIG;;;;;;;QAOH;;;;WAIG;;;;;;;QAOH;;;;;WAKG;;;;;;;;CAQG,CAAC"}