hanzo-dart/sdk
1
0
Fork 0
mirror of https://github.com/hanzo-dart/sdk.git synced 2026-10-30 19:32:47 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
main
sdk/lib/api/project_api.dart
T
zeekay cc53f61292 Regenerate against the document the deployment answers for 
The projection these were generated from predated the compute migration, so
they described /v1/visor — which the API serves at zero paths now.

No /v1/visor path survives here.
2026-09-05 18:55:43 -07:00

1721 lines
105 KiB
Dart
Raw Permalink Blame History

//
// AUTO-GENERATED FILE, DO NOT MODIFY!
//
// @dart=2.18
// ignore_for_file: unused_element, unused_import
// ignore_for_file: always_put_required_named_parameters_first
// ignore_for_file: constant_identifier_names
// ignore_for_file: lines_longer_than_80_chars
part of hanzoai.cloud;
class ProjectApi {
ProjectApi([ApiClient? apiClient]) : apiClient = apiClient ?? defaultApiClient;
final ApiClient apiClient;
/// Deletes a project and takes its site off the internet.
///
/// Deletes a project and takes its site off the internet. The metadata delete is authoritative and everything after it is best-effort, in this order: the public `<slug>` subdomain binding is released so the slug is free to reclaim, the release rows are dropped so a reclaimed slug never inherits the previous owner's rollback menu, the git source is retired on every copy it has so a reclaimed slug never adopts a repository left behind (visibility.go), the S3 origin is purged under BOTH `<org>/<slug>/` and the site's sibling release space, and the edge cache-tag is flushed. A failure in any of those is logged and the delete still answers 204 — resurrecting a project because a purge missed would be worse than a leaked prefix. Scope: a validated principal is required (403 without one) and the project is resolved within that principal's org, so another tenant's slug is a 404 and nothing of theirs is touched.
///
/// Note: This method returns the HTTP [Response].
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project to act on, from the path. It is unique within the caller's org and nowhere else, so another tenant's slug is a 404.
Future<Response> deleteProjectBySlugWithHttpInfo(String slug,) async {
// ignore: prefer_const_declarations
final path = r'/v1/project/{slug}'
.replaceAll('{slug}', slug);
// ignore: prefer_final_locals
Object? postBody;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>[];
return apiClient.invokeAPI(
path,
'DELETE',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// Deletes a project and takes its site off the internet.
///
/// Deletes a project and takes its site off the internet. The metadata delete is authoritative and everything after it is best-effort, in this order: the public `<slug>` subdomain binding is released so the slug is free to reclaim, the release rows are dropped so a reclaimed slug never inherits the previous owner's rollback menu, the git source is retired on every copy it has so a reclaimed slug never adopts a repository left behind (visibility.go), the S3 origin is purged under BOTH `<org>/<slug>/` and the site's sibling release space, and the edge cache-tag is flushed. A failure in any of those is logged and the delete still answers 204 — resurrecting a project because a purge missed would be worse than a leaked prefix. Scope: a validated principal is required (403 without one) and the project is resolved within that principal's org, so another tenant's slug is a 404 and nothing of theirs is touched.
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project to act on, from the path. It is unique within the caller's org and nowhere else, so another tenant's slug is a 404.
Future<void> deleteProjectBySlug(String slug,) async {
final response = await deleteProjectBySlugWithHttpInfo(slug,);
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
}
/// Gives a custom hostname back, so the name is free to reuse.
///
/// Gives a custom hostname back, so the name is free to reuse. A claim is FIRST-COME and global, so an add-only surface was not ownership but a leak: a customer who mistyped a domain, or claimed one they later moved elsewhere, could neither reuse it nor let anyone else. This is the third writer that closes it. The release is scoped to (host, org, slug), so it can only ever drop THIS tenant's own claim, and it is IDEMPOTENT: releasing a host we do not hold is a clean 204, never a 404 that would let a caller probe which hosts other tenants hold. The edge cache-tag is flushed, since the host stops routing here. Scope: a validated principal is required (403 without one) and the site is resolved within that principal's org, so another tenant's slug is a 404.
///
/// Note: This method returns the HTTP [Response].
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project the host is attached to, from the path.
///
/// * [String] host (required):
/// Host is the custom hostname, from the path. It is cleaned to its canonical form (lowercased, trailing dot dropped) before anything is looked up.
Future<Response> deleteProjectBySlugDomainsByHostWithHttpInfo(String slug, String host,) async {
// ignore: prefer_const_declarations
final path = r'/v1/project/{slug}/domains/{host}'
.replaceAll('{slug}', slug)
.replaceAll('{host}', host);
// ignore: prefer_final_locals
Object? postBody;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>[];
return apiClient.invokeAPI(
path,
'DELETE',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// Gives a custom hostname back, so the name is free to reuse.
///
/// Gives a custom hostname back, so the name is free to reuse. A claim is FIRST-COME and global, so an add-only surface was not ownership but a leak: a customer who mistyped a domain, or claimed one they later moved elsewhere, could neither reuse it nor let anyone else. This is the third writer that closes it. The release is scoped to (host, org, slug), so it can only ever drop THIS tenant's own claim, and it is IDEMPOTENT: releasing a host we do not hold is a clean 204, never a 404 that would let a caller probe which hosts other tenants hold. The edge cache-tag is flushed, since the host stops routing here. Scope: a validated principal is required (403 without one) and the site is resolved within that principal's org, so another tenant's slug is a 404.
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project the host is attached to, from the path.
///
/// * [String] host (required):
/// Host is the custom hostname, from the path. It is cleaned to its canonical form (lowercased, trailing dot dropped) before anything is looked up.
Future<void> deleteProjectBySlugDomainsByHost(String slug, String host,) async {
final response = await deleteProjectBySlugDomainsByHostWithHttpInfo(slug, host,);
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
}
/// Removes the caller's own bookmark from a project, and answers whether it is starred afterwards.
///
/// Removes the caller's own bookmark from a project, and answers whether it is starred afterwards. It removes only YOUR star — the same one star wrote — so a project other people have starred stays on their lists. Unstarring one you had not starred is not an error; it leaves it unstarred.
///
/// Note: This method returns the HTTP [Response].
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project to act on, from the path. It is unique within the caller's org and nowhere else, so another tenant's slug is a 404.
Future<Response> deleteProjectBySlugStarWithHttpInfo(String slug,) async {
// ignore: prefer_const_declarations
final path = r'/v1/project/{slug}/star'
.replaceAll('{slug}', slug);
// ignore: prefer_final_locals
Object? postBody;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>[];
return apiClient.invokeAPI(
path,
'DELETE',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// Removes the caller's own bookmark from a project, and answers whether it is starred afterwards.
///
/// Removes the caller's own bookmark from a project, and answers whether it is starred afterwards. It removes only YOUR star — the same one star wrote — so a project other people have starred stays on their lists. Unstarring one you had not starred is not an error; it leaves it unstarred.
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project to act on, from the path. It is unique within the caller's org and nowhere else, so another tenant's slug is a 404.
Future<ProjectsStar?> deleteProjectBySlugStar(String slug,) async {
final response = await deleteProjectBySlugStarWithHttpInfo(slug,);
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
// When a remote server returns no body with a status of 204, we shall not decode it.
// At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
// FormatException when trying to decode an empty string.
if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
return await apiClient.deserializeAsync(await _decodeBodyBytes(response), 'ProjectsStar',) as ProjectsStar;
}
return null;
}
/// Returns every project your org owns.
///
/// Returns every project your org owns. Each row carries the slug, name, framework, visibility, status and live URL — the same rows console and the builder render, because there is only one store behind both. It requires a validated principal (403 without one) and is keyed by that principal's org, so it never contains another tenant's project.
///
/// Note: This method returns the HTTP [Response].
Future<Response> getProjectWithHttpInfo() async {
// ignore: prefer_const_declarations
final path = r'/v1/project';
// ignore: prefer_final_locals
Object? postBody;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>[];
return apiClient.invokeAPI(
path,
'GET',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// Returns every project your org owns.
///
/// Returns every project your org owns. Each row carries the slug, name, framework, visibility, status and live URL — the same rows console and the builder render, because there is only one store behind both. It requires a validated principal (403 without one) and is keyed by that principal's org, so it never contains another tenant's project.
Future<List<ProjectsProject>?> getProject() async {
final response = await getProjectWithHttpInfo();
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
// When a remote server returns no body with a status of 204, we shall not decode it.
// At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
// FormatException when trying to decode an empty string.
if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
final responseBody = await _decodeBodyBytes(response);
return (await apiClient.deserializeAsync(responseBody, 'List<ProjectsProject>') as List)
.cast<ProjectsProject>()
.toList(growable: false);
}
return null;
}
/// Returns one project of yours by slug — its settings, its live URL and the deployment currently serving it.
///
/// Returns one project of yours by slug — its settings, its live URL and the deployment currently serving it. Scope: a validated principal is required (403 without one) and the lookup is keyed by (org, slug), so another tenant's slug is a 404 exactly like a nonexistent one.
///
/// Note: This method returns the HTTP [Response].
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project to act on, from the path. It is unique within the caller's org and nowhere else, so another tenant's slug is a 404.
Future<Response> getProjectBySlugWithHttpInfo(String slug,) async {
// ignore: prefer_const_declarations
final path = r'/v1/project/{slug}'
.replaceAll('{slug}', slug);
// ignore: prefer_final_locals
Object? postBody;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>[];
return apiClient.invokeAPI(
path,
'GET',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// Returns one project of yours by slug — its settings, its live URL and the deployment currently serving it.
///
/// Returns one project of yours by slug — its settings, its live URL and the deployment currently serving it. Scope: a validated principal is required (403 without one) and the lookup is keyed by (org, slug), so another tenant's slug is a 404 exactly like a nonexistent one.
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project to act on, from the path. It is unique within the caller's org and nowhere else, so another tenant's slug is a 404.
Future<ProjectsProject?> getProjectBySlug(String slug,) async {
final response = await getProjectBySlugWithHttpInfo(slug,);
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
// When a remote server returns no body with a status of 204, we shall not decode it.
// At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
// FormatException when trying to decode an empty string.
if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
return await apiClient.deserializeAsync(await _decodeBodyBytes(response), 'ProjectsProject',) as ProjectsProject;
}
return null;
}
/// Returns a project's deploy history, newest version first.
///
/// Returns a project's deploy history, newest version first. Every deploy of the project is a row — uploads, generated sites, and git/CI builds alike — carrying its version, status, source, commit, live URL, file count and byte count. The short-lived upload grant a queued git deployment was handed is NOT replayed here: it exists only on the 202 that minted it, so a grant cannot outlive its build by being fetched again. Scope: a validated principal is required (403 without one) and the project is resolved within that principal's org, so another tenant's slug is a 404.
///
/// Note: This method returns the HTTP [Response].
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project to act on, from the path. It is unique within the caller's org and nowhere else, so another tenant's slug is a 404.
Future<Response> getProjectBySlugDeploymentsWithHttpInfo(String slug,) async {
// ignore: prefer_const_declarations
final path = r'/v1/project/{slug}/deployments'
.replaceAll('{slug}', slug);
// ignore: prefer_final_locals
Object? postBody;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>[];
return apiClient.invokeAPI(
path,
'GET',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// Returns a project's deploy history, newest version first.
///
/// Returns a project's deploy history, newest version first. Every deploy of the project is a row — uploads, generated sites, and git/CI builds alike — carrying its version, status, source, commit, live URL, file count and byte count. The short-lived upload grant a queued git deployment was handed is NOT replayed here: it exists only on the 202 that minted it, so a grant cannot outlive its build by being fetched again. Scope: a validated principal is required (403 without one) and the project is resolved within that principal's org, so another tenant's slug is a 404.
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project to act on, from the path. It is unique within the caller's org and nowhere else, so another tenant's slug is a 404.
Future<List<ProjectsDeployment>?> getProjectBySlugDeployments(String slug,) async {
final response = await getProjectBySlugDeploymentsWithHttpInfo(slug,);
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
// When a remote server returns no body with a status of 204, we shall not decode it.
// At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
// FormatException when trying to decode an empty string.
if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
final responseBody = await _decodeBodyBytes(response);
return (await apiClient.deserializeAsync(responseBody, 'List<ProjectsDeployment>') as List)
.cast<ProjectsDeployment>()
.toList(growable: false);
}
return null;
}
/// Returns one deployment of a project by id.
///
/// Returns one deployment of a project by id. It is how a console follows a build: the status (`queued`, `uploading`, `live`, `error`), the message a failure left, and the URL and prefix it went live at. Like the history, it never replays the upload grant. Scope: a validated principal is required (403 without one). Both the project and the deployment are resolved within that principal's org, so a deployment of another project — or of another tenant — is a 404.
///
/// Note: This method returns the HTTP [Response].
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project the deployment belongs to, from the path.
///
/// * [String] id (required):
/// ID is the deployment id, from the path. A deployment of another project — or of another tenant's project — is not found.
Future<Response> getProjectBySlugDeploymentsByIdWithHttpInfo(String slug, String id,) async {
// ignore: prefer_const_declarations
final path = r'/v1/project/{slug}/deployments/{id}'
.replaceAll('{slug}', slug)
.replaceAll('{id}', id);
// ignore: prefer_final_locals
Object? postBody;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>[];
return apiClient.invokeAPI(
path,
'GET',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// Returns one deployment of a project by id.
///
/// Returns one deployment of a project by id. It is how a console follows a build: the status (`queued`, `uploading`, `live`, `error`), the message a failure left, and the URL and prefix it went live at. Like the history, it never replays the upload grant. Scope: a validated principal is required (403 without one). Both the project and the deployment are resolved within that principal's org, so a deployment of another project — or of another tenant — is a 404.
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project the deployment belongs to, from the path.
///
/// * [String] id (required):
/// ID is the deployment id, from the path. A deployment of another project — or of another tenant's project — is not found.
Future<ProjectsDeployment?> getProjectBySlugDeploymentsById(String slug, String id,) async {
final response = await getProjectBySlugDeploymentsByIdWithHttpInfo(slug, id,);
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
// When a remote server returns no body with a status of 204, we shall not decode it.
// At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
// FormatException when trying to decode an empty string.
if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
return await apiClient.deserializeAsync(await _decodeBodyBytes(response), 'ProjectsDeployment',) as ProjectsDeployment;
}
return null;
}
/// Returns every custom hostname this site holds: the live ones, plus any pending claim with the DNS records it still owes.
///
/// Returns every custom hostname this site holds: the live ones, plus any pending claim with the DNS records it still owes. `domains` is the routing answer — the hosts that are verified right now — while `claims` is the full panel, one row per host, each saying whether it is live or pending and, if pending, exactly what to publish. Scope: a validated principal is required (403 without one) and the site is resolved within that principal's org, so another tenant's slug is a 404.
///
/// Note: This method returns the HTTP [Response].
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project to act on, from the path. It is unique within the caller's org and nowhere else, so another tenant's slug is a 404.
Future<Response> getProjectBySlugDomainsWithHttpInfo(String slug,) async {
// ignore: prefer_const_declarations
final path = r'/v1/project/{slug}/domains'
.replaceAll('{slug}', slug);
// ignore: prefer_final_locals
Object? postBody;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>[];
return apiClient.invokeAPI(
path,
'GET',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// Returns every custom hostname this site holds: the live ones, plus any pending claim with the DNS records it still owes.
///
/// Returns every custom hostname this site holds: the live ones, plus any pending claim with the DNS records it still owes. `domains` is the routing answer — the hosts that are verified right now — while `claims` is the full panel, one row per host, each saying whether it is live or pending and, if pending, exactly what to publish. Scope: a validated principal is required (403 without one) and the site is resolved within that principal's org, so another tenant's slug is a 404.
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project to act on, from the path. It is unique within the caller's org and nowhere else, so another tenant's slug is a 404.
Future<ProjectsDomains?> getProjectBySlugDomains(String slug,) async {
final response = await getProjectBySlugDomainsWithHttpInfo(slug,);
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
// When a remote server returns no body with a status of 204, we shall not decode it.
// At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
// FormatException when trying to decode an empty string.
if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
return await apiClient.deserializeAsync(await _decodeBodyBytes(response), 'ProjectsDomains',) as ProjectsDomains;
}
return null;
}
/// Returns a site's releases newest-first, marking the active one — the rollback menu.
///
/// Returns a site's releases newest-first, marking the active one — the rollback menu. Each row carries the release id to activate, the source it was promoted from, its object and byte counts, and the URL if it is the one serving. Retention bounds the list, so it is the set that can actually still be rolled back to, not a full history. Scope: a validated principal is required (403 without one) and the site is resolved within that principal's org, so another tenant's slug is a 404.
///
/// Note: This method returns the HTTP [Response].
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project to act on, from the path. It is unique within the caller's org and nowhere else, so another tenant's slug is a 404.
Future<Response> getProjectBySlugReleasesWithHttpInfo(String slug,) async {
// ignore: prefer_const_declarations
final path = r'/v1/project/{slug}/releases'
.replaceAll('{slug}', slug);
// ignore: prefer_final_locals
Object? postBody;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>[];
return apiClient.invokeAPI(
path,
'GET',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// Returns a site's releases newest-first, marking the active one — the rollback menu.
///
/// Returns a site's releases newest-first, marking the active one — the rollback menu. Each row carries the release id to activate, the source it was promoted from, its object and byte counts, and the URL if it is the one serving. Retention bounds the list, so it is the set that can actually still be rolled back to, not a full history. Scope: a validated principal is required (403 without one) and the site is resolved within that principal's org, so another tenant's slug is a 404.
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project to act on, from the path. It is unique within the caller's org and nowhere else, so another tenant's slug is a 404.
Future<List<ProjectsRelease>?> getProjectBySlugReleases(String slug,) async {
final response = await getProjectBySlugReleasesWithHttpInfo(slug,);
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
// When a remote server returns no body with a status of 204, we shall not decode it.
// At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
// FormatException when trying to decode an empty string.
if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
final responseBody = await _decodeBodyBytes(response);
return (await apiClient.deserializeAsync(responseBody, 'List<ProjectsRelease>') as List)
.cast<ProjectsRelease>()
.toList(growable: false);
}
return null;
}
/// Get a PNG of the project's live site
///
/// Returns a screenshot of what this project currently serves, as image/png. The capture is keyed by the deployment, so a redeploy invalidates it by construction rather than by anyone remembering to clear a cache. A project with nothing deployed answers 404 — that is a 404 about the PICTURE and not about the project, which is still right there in the list. Scoped to the caller's org: a validated principal is required, and a slug belonging to another org is not found rather than forbidden.
///
/// Note: This method returns the HTTP [Response].
///
/// Parameters:
///
/// * [String] slug (required):
Future<Response> getProjectBySlugShotWithHttpInfo(String slug,) async {
// ignore: prefer_const_declarations
final path = r'/v1/project/{slug}/shot'
.replaceAll('{slug}', slug);
// ignore: prefer_final_locals
Object? postBody;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>[];
return apiClient.invokeAPI(
path,
'GET',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// Get a PNG of the project's live site
///
/// Returns a screenshot of what this project currently serves, as image/png. The capture is keyed by the deployment, so a redeploy invalidates it by construction rather than by anyone remembering to clear a cache. A project with nothing deployed answers 404 — that is a 404 about the PICTURE and not about the project, which is still right there in the list. Scoped to the caller's org: a validated principal is required, and a slug belonging to another org is not found rather than forbidden.
///
/// Parameters:
///
/// * [String] slug (required):
Future<void> getProjectBySlugShot(String slug,) async {
final response = await getProjectBySlugShotWithHttpInfo(slug,);
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
}
/// health reports whether a publish reaches readers, rather than whether it was accepted.
///
/// health reports whether a publish reaches readers, rather than whether it was accepted. Those are different questions and only the second one was ever visible. It asks the edge and nothing else. There is no live call to the provider here: Configured is a local fact, it is the fact that was missing, and a health check that spends a third-party API call is one an operator learns not to run.
///
/// Note: This method returns the HTTP [Response].
Future<Response> getProjectEdgeWithHttpInfo() async {
// ignore: prefer_const_declarations
final path = r'/v1/project/edge';
// ignore: prefer_final_locals
Object? postBody;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>[];
return apiClient.invokeAPI(
path,
'GET',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// health reports whether a publish reaches readers, rather than whether it was accepted.
///
/// health reports whether a publish reaches readers, rather than whether it was accepted. Those are different questions and only the second one was ever visible. It asks the edge and nothing else. There is no live call to the provider here: Configured is a local fact, it is the fact that was missing, and a health check that spends a third-party API call is one an operator learns not to run.
Future<EdgeState?> getProjectEdge() async {
final response = await getProjectEdgeWithHttpInfo();
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
// When a remote server returns no body with a status of 204, we shall not decode it.
// At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
// FormatException when trying to decode an empty string.
if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
return await apiClient.deserializeAsync(await _decodeBodyBytes(response), 'EdgeState',) as EdgeState;
}
return null;
}
/// Returns the org's deployed sites at the pretty URLs they serve at.
///
/// Returns the org's deployed sites at the pretty URLs they serve at. It reads the SAME org-scoped store as /v1/project and keeps only the projects that are actually `live`, so a draft or a failed build is not advertised as a site. Scope: a validated principal is required (403 without one) and the list is keyed by that principal's org.
///
/// Note: This method returns the HTTP [Response].
Future<Response> getProjectSitesWithHttpInfo() async {
// ignore: prefer_const_declarations
final path = r'/v1/project/sites';
// ignore: prefer_final_locals
Object? postBody;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>[];
return apiClient.invokeAPI(
path,
'GET',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// Returns the org's deployed sites at the pretty URLs they serve at.
///
/// Returns the org's deployed sites at the pretty URLs they serve at. It reads the SAME org-scoped store as /v1/project and keeps only the projects that are actually `live`, so a draft or a failed build is not advertised as a site. Scope: a validated principal is required (403 without one) and the list is keyed by that principal's org.
Future<List<ProjectsSite>?> getProjectSites() async {
final response = await getProjectSitesWithHttpInfo();
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
// When a remote server returns no body with a status of 204, we shall not decode it.
// At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
// FormatException when trying to decode an empty string.
if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
final responseBody = await _decodeBodyBytes(response);
return (await apiClient.deserializeAsync(responseBody, 'List<ProjectsSite>') as List)
.cast<ProjectsSite>()
.toList(growable: false);
}
return null;
}
/// Returns one site — the same row ListSites carries, for one slug.
///
/// Returns one site — the same row ListSites carries, for one slug. Every sub-resource under a site already answered: deployments, releases, publish. The site itself did not, and a route that is never registered answers 404 for a LIVE site exactly as it does for one that was never created. So the one call a client makes to ask \"is it there yet?\" could only ever say no, and a CI lane watching for its own publish would wait forever on a success it had already achieved. The org is the caller's, never a path segment. A slug is unique within an org and two orgs may both own `tel`; taking the org from the validated principal instead of the URL means a caller cannot read another org's site by editing a path, and it is the same scope ListProjects and ListSites already use. A site that exists but is not live is NOT found here, matching ListSites, which keeps only `live` rows so a draft or a failed build is never advertised as a site. One definition of \"is a site\", used by both.
///
/// Note: This method returns the HTTP [Response].
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project to act on, from the path. It is unique within the caller's org and nowhere else, so another tenant's slug is a 404.
Future<Response> getProjectSitesBySlugWithHttpInfo(String slug,) async {
// ignore: prefer_const_declarations
final path = r'/v1/project/sites/{slug}'
.replaceAll('{slug}', slug);
// ignore: prefer_final_locals
Object? postBody;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>[];
return apiClient.invokeAPI(
path,
'GET',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// Returns one site — the same row ListSites carries, for one slug.
///
/// Returns one site — the same row ListSites carries, for one slug. Every sub-resource under a site already answered: deployments, releases, publish. The site itself did not, and a route that is never registered answers 404 for a LIVE site exactly as it does for one that was never created. So the one call a client makes to ask \"is it there yet?\" could only ever say no, and a CI lane watching for its own publish would wait forever on a success it had already achieved. The org is the caller's, never a path segment. A slug is unique within an org and two orgs may both own `tel`; taking the org from the validated principal instead of the URL means a caller cannot read another org's site by editing a path, and it is the same scope ListProjects and ListSites already use. A site that exists but is not live is NOT found here, matching ListSites, which keeps only `live` rows so a draft or a failed build is never advertised as a site. One definition of \"is a site\", used by both.
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project to act on, from the path. It is unique within the caller's org and nowhere else, so another tenant's slug is a 404.
Future<ProjectsSite?> getProjectSitesBySlug(String slug,) async {
final response = await getProjectSitesBySlugWithHttpInfo(slug,);
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
// When a remote server returns no body with a status of 204, we shall not decode it.
// At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
// FormatException when trying to decode an empty string.
if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
return await apiClient.deserializeAsync(await _decodeBodyBytes(response), 'ProjectsSite',) as ProjectsSite;
}
return null;
}
/// The site's browser tag set for the hosted tag — which pixels to inject, by publishable key
///
/// Returns the client-side pixels the SITE has connected (GA4, Google Ads, LinkedIn, Meta, Pinterest, Reddit, TikTok, X) with their NON-SECRET ids, so the hosted tag injects them first-party and stamps each browser event with the same event_id the server-side Conversions API uses — deduping the two. Resolved per site: by the publishable key on ?key= when it names a project, else by the request host, so hanzo.ai and hanzo.chat carry different tags under one org. WITHOUT a resolvable site it answers an empty set at 200 — a page never breaks on its tag config.
///
/// Note: This method returns the HTTP [Response].
Future<Response> getProjectTagsWithHttpInfo() async {
// ignore: prefer_const_declarations
final path = r'/v1/project/tags';
// ignore: prefer_final_locals
Object? postBody;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>[];
return apiClient.invokeAPI(
path,
'GET',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// The site's browser tag set for the hosted tag — which pixels to inject, by publishable key
///
/// Returns the client-side pixels the SITE has connected (GA4, Google Ads, LinkedIn, Meta, Pinterest, Reddit, TikTok, X) with their NON-SECRET ids, so the hosted tag injects them first-party and stamps each browser event with the same event_id the server-side Conversions API uses — deduping the two. Resolved per site: by the publishable key on ?key= when it names a project, else by the request host, so hanzo.ai and hanzo.chat carry different tags under one org. WITHOUT a resolvable site it answers an empty set at 200 — a page never breaks on its tag config.
Future<TagConfig?> getProjectTags() async {
final response = await getProjectTagsWithHttpInfo();
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
// When a remote server returns no body with a status of 204, we shall not decode it.
// At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
// FormatException when trying to decode an empty string.
if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
return await apiClient.deserializeAsync(await _decodeBodyBytes(response), 'TagConfig',) as TagConfig;
}
return null;
}
/// Changes a project's settings, and only the settings you send.
///
/// Changes a project's settings, and only the settings you send. Every field is optional and absent means \"leave it\": `name` may not be blanked, `framework` must stay a known build hint, and `cacheControl` is capped at 256 characters with no newlines (it becomes a response header). `visibility` flips public/private under the same rule as create — public is free, private needs a funded org. `upstream` and `license` are free-text credit for third-party work, and sending \"\" clears one. Changing anything reconciles the project's canonical git repo, so a visibility change reaches the source and not just the listing. `hidden`/`hiddenReason` are platform MODERATION and are ignored unless the caller is a platform admin; they remove a project from the public catalogue without touching the publisher's own visibility choice, so un-hiding restores exactly what they asked for. Scope: a validated principal is required (403 without one) and the project is resolved within that principal's org, so another tenant's slug is a 404.
///
/// Note: This method returns the HTTP [Response].
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project to update, from the path. The URL is the addressing authority — a `slug` in the body cannot move the write to another project.
///
/// * [ProjectsUpdate] projectsUpdate (required):
Future<Response> patchProjectBySlugWithHttpInfo(String slug, ProjectsUpdate projectsUpdate,) async {
// ignore: prefer_const_declarations
final path = r'/v1/project/{slug}'
.replaceAll('{slug}', slug);
// ignore: prefer_final_locals
Object? postBody = projectsUpdate;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>['application/json'];
return apiClient.invokeAPI(
path,
'PATCH',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// Changes a project's settings, and only the settings you send.
///
/// Changes a project's settings, and only the settings you send. Every field is optional and absent means \"leave it\": `name` may not be blanked, `framework` must stay a known build hint, and `cacheControl` is capped at 256 characters with no newlines (it becomes a response header). `visibility` flips public/private under the same rule as create — public is free, private needs a funded org. `upstream` and `license` are free-text credit for third-party work, and sending \"\" clears one. Changing anything reconciles the project's canonical git repo, so a visibility change reaches the source and not just the listing. `hidden`/`hiddenReason` are platform MODERATION and are ignored unless the caller is a platform admin; they remove a project from the public catalogue without touching the publisher's own visibility choice, so un-hiding restores exactly what they asked for. Scope: a validated principal is required (403 without one) and the project is resolved within that principal's org, so another tenant's slug is a 404.
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project to update, from the path. The URL is the addressing authority — a `slug` in the body cannot move the write to another project.
///
/// * [ProjectsUpdate] projectsUpdate (required):
Future<ProjectsProject?> patchProjectBySlug(String slug, ProjectsUpdate projectsUpdate,) async {
final response = await patchProjectBySlugWithHttpInfo(slug, projectsUpdate,);
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
// When a remote server returns no body with a status of 204, we shall not decode it.
// At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
// FormatException when trying to decode an empty string.
if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
return await apiClient.deserializeAsync(await _decodeBodyBytes(response), 'ProjectsProject',) as ProjectsProject;
}
return null;
}
/// Creates a project — the handle a site is deployed and served under — and answers 201 with it in `draft`.
///
/// Creates a project — the handle a site is deployed and served under — and answers 201 with it in `draft`. `name` is required; `slug` is derived from the name when omitted and is the identifier that matters — it becomes the S3 key segment, the public host `<slug>.hanzo.app`, and the handle every later call addresses, so it must match `^[a-z0-9]([a-z0-9-]{0,38}[a-z0-9])?$` and may not be a reserved label such as `api` or `admin`. `framework` is a build hint from a closed set, defaulting to `static`; it never gates a deploy, it only tells CI how to build a linked repo. Two defaults are worth knowing: the analytics beacon is ON unless `analytics` is explicitly false, and `visibility` is `public` unless asked otherwise. Publishing publicly is free; PRIVATE is the paid feature, and an unfunded org asking for it is refused rather than quietly published as public. Creation also provisions the project's data space and a canonical git repo, both best-effort — neither can fail the create. Scope: a validated principal is required (403 without one) and the project is created in THAT principal's org. The slug is unique per org, so a slug already used in the caller's own org is a 409 while the same slug in another org is irrelevant.
///
/// Note: This method returns the HTTP [Response].
///
/// Parameters:
///
/// * [ProjectsCreate] projectsCreate (required):
Future<Response> postProjectWithHttpInfo(ProjectsCreate projectsCreate,) async {
// ignore: prefer_const_declarations
final path = r'/v1/project';
// ignore: prefer_final_locals
Object? postBody = projectsCreate;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>['application/json'];
return apiClient.invokeAPI(
path,
'POST',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// Creates a project — the handle a site is deployed and served under — and answers 201 with it in `draft`.
///
/// Creates a project — the handle a site is deployed and served under — and answers 201 with it in `draft`. `name` is required; `slug` is derived from the name when omitted and is the identifier that matters — it becomes the S3 key segment, the public host `<slug>.hanzo.app`, and the handle every later call addresses, so it must match `^[a-z0-9]([a-z0-9-]{0,38}[a-z0-9])?$` and may not be a reserved label such as `api` or `admin`. `framework` is a build hint from a closed set, defaulting to `static`; it never gates a deploy, it only tells CI how to build a linked repo. Two defaults are worth knowing: the analytics beacon is ON unless `analytics` is explicitly false, and `visibility` is `public` unless asked otherwise. Publishing publicly is free; PRIVATE is the paid feature, and an unfunded org asking for it is refused rather than quietly published as public. Creation also provisions the project's data space and a canonical git repo, both best-effort — neither can fail the create. Scope: a validated principal is required (403 without one) and the project is created in THAT principal's org. The slug is unique per org, so a slug already used in the caller's own org is a 409 while the same slug in another org is irrelevant.
///
/// Parameters:
///
/// * [ProjectsCreate] projectsCreate (required):
Future<ProjectsProject?> postProject(ProjectsCreate projectsCreate,) async {
final response = await postProjectWithHttpInfo(projectsCreate,);
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
// When a remote server returns no body with a status of 204, we shall not decode it.
// At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
// FormatException when trying to decode an empty string.
if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
return await apiClient.deserializeAsync(await _decodeBodyBytes(response), 'ProjectsProject',) as ProjectsProject;
}
return null;
}
/// Upload a built site as one archive and serve it
///
/// Takes a built site live at `https://<slug>.hanzo.app` in one call. The body is the site itself — a `zip` or `tar.gz` holding `index.html` at its root (or a single wrapper directory that does), sent raw or as a multipart file part. It is unpacked to the site's own storage prefix and served immediately, answering the finished deployment. It is bounded by the edge body limit (16 MiB by default), and that bound is the whole reason the other path exists: an oversized POST is refused by the server BEFORE any handler runs and surfaces as an opaque `400 Error when parsing request` that reads like a malformed payload rather than a size cap. A site too large for one archive opens a deployment with `POST /v1/project/{slug}/deployments` instead and writes its files straight to storage against the scoped grant that answers with — no body limit, and no bytes through this API at all. Billing is fail-closed and fails FIRST: the hosting gate runs before anything is parsed or uploaded, so an unfunded org is 402 and an unreachable commerce is 503 with nothing written. The debit lands only on success — a failed upload is never billed and never flips the live site — and a redeploy answers the SAME URL, because slug and apex are stable. Scope: a validated principal is required (403 without one) and the site is resolved within that principal's org, so another tenant's slug is a 404. Object storage must be configured (503); an archive that does not walk is a 400 and one over the size cap is a 413.
///
/// Note: This method returns the HTTP [Response].
///
/// Parameters:
///
/// * [String] slug (required):
///
/// * [MultipartFile] body:
Future<Response> postProjectBySlugDeployWithHttpInfo(String slug, { MultipartFile? body, }) async {
// ignore: prefer_const_declarations
final path = r'/v1/project/{slug}/deploy'
.replaceAll('{slug}', slug);
// ignore: prefer_final_locals
Object? postBody = body;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>['application/octet-stream'];
return apiClient.invokeAPI(
path,
'POST',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// Upload a built site as one archive and serve it
///
/// Takes a built site live at `https://<slug>.hanzo.app` in one call. The body is the site itself — a `zip` or `tar.gz` holding `index.html` at its root (or a single wrapper directory that does), sent raw or as a multipart file part. It is unpacked to the site's own storage prefix and served immediately, answering the finished deployment. It is bounded by the edge body limit (16 MiB by default), and that bound is the whole reason the other path exists: an oversized POST is refused by the server BEFORE any handler runs and surfaces as an opaque `400 Error when parsing request` that reads like a malformed payload rather than a size cap. A site too large for one archive opens a deployment with `POST /v1/project/{slug}/deployments` instead and writes its files straight to storage against the scoped grant that answers with — no body limit, and no bytes through this API at all. Billing is fail-closed and fails FIRST: the hosting gate runs before anything is parsed or uploaded, so an unfunded org is 402 and an unreachable commerce is 503 with nothing written. The debit lands only on success — a failed upload is never billed and never flips the live site — and a redeploy answers the SAME URL, because slug and apex are stable. Scope: a validated principal is required (403 without one) and the site is resolved within that principal's org, so another tenant's slug is a 404. Object storage must be configured (503); an archive that does not walk is a 400 and one over the size cap is a 413.
///
/// Parameters:
///
/// * [String] slug (required):
///
/// * [MultipartFile] body:
Future<ProjectsDeployment?> postProjectBySlugDeploy(String slug, { MultipartFile? body, }) async {
final response = await postProjectBySlugDeployWithHttpInfo(slug, body: body, );
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
// When a remote server returns no body with a status of 204, we shall not decode it.
// At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
// FormatException when trying to decode an empty string.
if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
return await apiClient.deserializeAsync(await _decodeBodyBytes(response), 'ProjectsDeployment',) as ProjectsDeployment;
}
return null;
}
/// Opens a deployment and hands back a short-lived, prefix-scoped grant to write its bytes straight to object storage.
///
/// Opens a deployment and hands back a short-lived, prefix-scoped grant to write its bytes straight to object storage. Answers 202. This is the path for a site too large to send as one archive: a real export is hundreds of megabytes against a 16 MiB body limit, so the bytes deliberately do NOT pass through the API. The answer carries `bucket`, `prefix` and `upload` — a presigned POST policy that S3 itself confines to this site's prefix (starts-with `<org>/<slug>/`), expires in 30 minutes and bounds each object. So a build writes its own files and holds no standing bucket credential; there is nothing to rotate and nothing that leaks between tenants. Never guess the prefix — it is server-derived, and a guessed one lands where nothing is served. The deployment is `queued` until POST .../deployments/{id}/complete flips it live (or error). That completion is also where DELETION happens: the grant authorizes writes only, so a build cannot remove a file, and cloud reconciles the prefix against the `keys` manifest the completion carries. A build that dies before completing leaves the deployment queued rather than a half-live site. The grant is on the 202 and NOWHERE else — it is never stored and never replayed on a later read, so it cannot outlive the build it was minted for. A deployment whose grant could not be minted is still created and still completable; it simply carries no `upload`, and a caller with no other way to write should treat that as the failure it is. Billing: the hosting gate runs BEFORE anything is created (402 unfunded, 503 commerce unreachable), and the debit lands on the completion that goes live — never on a queued or failed build. Scope: a validated principal is required (403 without one) and the site is resolved within that principal's org, so another tenant's slug is a 404.
///
/// Note: This method returns the HTTP [Response].
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the site to deploy, from the path.
///
/// * [ProjectsDeployStart] projectsDeployStart (required):
Future<Response> postProjectBySlugDeploymentsWithHttpInfo(String slug, ProjectsDeployStart projectsDeployStart,) async {
// ignore: prefer_const_declarations
final path = r'/v1/project/{slug}/deployments'
.replaceAll('{slug}', slug);
// ignore: prefer_final_locals
Object? postBody = projectsDeployStart;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>['application/json'];
return apiClient.invokeAPI(
path,
'POST',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// Opens a deployment and hands back a short-lived, prefix-scoped grant to write its bytes straight to object storage.
///
/// Opens a deployment and hands back a short-lived, prefix-scoped grant to write its bytes straight to object storage. Answers 202. This is the path for a site too large to send as one archive: a real export is hundreds of megabytes against a 16 MiB body limit, so the bytes deliberately do NOT pass through the API. The answer carries `bucket`, `prefix` and `upload` — a presigned POST policy that S3 itself confines to this site's prefix (starts-with `<org>/<slug>/`), expires in 30 minutes and bounds each object. So a build writes its own files and holds no standing bucket credential; there is nothing to rotate and nothing that leaks between tenants. Never guess the prefix — it is server-derived, and a guessed one lands where nothing is served. The deployment is `queued` until POST .../deployments/{id}/complete flips it live (or error). That completion is also where DELETION happens: the grant authorizes writes only, so a build cannot remove a file, and cloud reconciles the prefix against the `keys` manifest the completion carries. A build that dies before completing leaves the deployment queued rather than a half-live site. The grant is on the 202 and NOWHERE else — it is never stored and never replayed on a later read, so it cannot outlive the build it was minted for. A deployment whose grant could not be minted is still created and still completable; it simply carries no `upload`, and a caller with no other way to write should treat that as the failure it is. Billing: the hosting gate runs BEFORE anything is created (402 unfunded, 503 commerce unreachable), and the debit lands on the completion that goes live — never on a queued or failed build. Scope: a validated principal is required (403 without one) and the site is resolved within that principal's org, so another tenant's slug is a 404.
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the site to deploy, from the path.
///
/// * [ProjectsDeployStart] projectsDeployStart (required):
Future<ProjectsDeployment?> postProjectBySlugDeployments(String slug, ProjectsDeployStart projectsDeployStart,) async {
final response = await postProjectBySlugDeploymentsWithHttpInfo(slug, projectsDeployStart,);
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
// When a remote server returns no body with a status of 204, we shall not decode it.
// At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
// FormatException when trying to decode an empty string.
if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
return await apiClient.deserializeAsync(await _decodeBodyBytes(response), 'ProjectsDeployment',) as ProjectsDeployment;
}
return null;
}
/// CompleteDeployment is the CI completion hook that flips a queued git deployment to live (or error) once CI has synced the built site to S3.
///
/// CompleteDeployment is the CI completion hook that flips a queued git deployment to live (or error) once CI has synced the built site to S3. `status` must be `live` or `error`. On a LIVE completion the public host is claimed FIRST, so the deployment reports the URL it actually OWNS — a CI-supplied `liveUrl` is a hint that can refine that URL but can never assert a subdomain another tenant holds. `keys` is the manifest CI just uploaded, relative to the deployment prefix: cloud reconciles the prefix against it so a page deleted from the build actually stops serving. Omit `keys` and nothing is deleted — the prefix only grows. Reconciliation runs only on a live completion (pruning against a failed build's manifest would delete the site the last good build is still serving) and is best-effort, so a stale leftover never turns a successful deploy into a 500. A live completion is also the one billable moment on the git path; an error completion bills nothing. Scope: a validated principal is required (403 without one). CI authenticates with an org-scoped token through the gateway, so the deployment is resolved within that principal's org and another tenant's slug or deployment id is a 404.
///
/// Note: This method returns the HTTP [Response].
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project the deployment belongs to, from the path.
///
/// * [String] id (required):
/// ID is the queued deployment to complete, from the path.
///
/// * [ProjectsComplete] projectsComplete (required):
Future<Response> postProjectBySlugDeploymentsByIdCompleteWithHttpInfo(String slug, String id, ProjectsComplete projectsComplete,) async {
// ignore: prefer_const_declarations
final path = r'/v1/project/{slug}/deployments/{id}/complete'
.replaceAll('{slug}', slug)
.replaceAll('{id}', id);
// ignore: prefer_final_locals
Object? postBody = projectsComplete;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>['application/json'];
return apiClient.invokeAPI(
path,
'POST',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// CompleteDeployment is the CI completion hook that flips a queued git deployment to live (or error) once CI has synced the built site to S3.
///
/// CompleteDeployment is the CI completion hook that flips a queued git deployment to live (or error) once CI has synced the built site to S3. `status` must be `live` or `error`. On a LIVE completion the public host is claimed FIRST, so the deployment reports the URL it actually OWNS — a CI-supplied `liveUrl` is a hint that can refine that URL but can never assert a subdomain another tenant holds. `keys` is the manifest CI just uploaded, relative to the deployment prefix: cloud reconciles the prefix against it so a page deleted from the build actually stops serving. Omit `keys` and nothing is deleted — the prefix only grows. Reconciliation runs only on a live completion (pruning against a failed build's manifest would delete the site the last good build is still serving) and is best-effort, so a stale leftover never turns a successful deploy into a 500. A live completion is also the one billable moment on the git path; an error completion bills nothing. Scope: a validated principal is required (403 without one). CI authenticates with an org-scoped token through the gateway, so the deployment is resolved within that principal's org and another tenant's slug or deployment id is a 404.
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project the deployment belongs to, from the path.
///
/// * [String] id (required):
/// ID is the queued deployment to complete, from the path.
///
/// * [ProjectsComplete] projectsComplete (required):
Future<ProjectsDeployment?> postProjectBySlugDeploymentsByIdComplete(String slug, String id, ProjectsComplete projectsComplete,) async {
final response = await postProjectBySlugDeploymentsByIdCompleteWithHttpInfo(slug, id, projectsComplete,);
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
// When a remote server returns no body with a status of 204, we shall not decode it.
// At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
// FormatException when trying to decode an empty string.
if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
return await apiClient.deserializeAsync(await _decodeBodyBytes(response), 'ProjectsDeployment',) as ProjectsDeployment;
}
return null;
}
/// Attaches one or more CUSTOM public hostnames to this org's site.
///
/// Attaches one or more CUSTOM public hostnames to this org's site. Binding a host you do not own would let you shadow it at the edge, so which outcome you get depends on whether ownership is already established: a SuperAdmin vouches (the operator manages the customer's DNS, so its bind IS the proof) and binds VERIFIED immediately; every other caller, INCLUDING an admin of the deployment's own brand org, has the host CLAIMED as pending and gets the DNS challenge back in `bound[].records`. A pending claim HOLDS the name so nobody else can take it, but it does not route until POST .../domains/{host}/verify proves control. A hostname we operate is refused to a non-vouched caller (those are assigned by the platform, never claimed), a host another site already holds is a 409, and a name the platform holds is a 400 for EVERY caller — a vouch skips the ownership proof, never the host table's own invariant. Claims and binds are idempotent for the same (org, slug), and re-claiming returns the SAME token rather than invalidating a record the customer has already published. The edge cache-tag is flushed afterwards so a newly-verified host serves the current build immediately. Scope: a validated principal is required (403 without one) and the site is resolved within that principal's org, so another tenant's slug is a 404.
///
/// Note: This method returns the HTTP [Response].
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the site the hosts attach to, from the path.
///
/// * [ProjectsDomainsBind] projectsDomainsBind (required):
Future<Response> postProjectBySlugDomainsWithHttpInfo(String slug, ProjectsDomainsBind projectsDomainsBind,) async {
// ignore: prefer_const_declarations
final path = r'/v1/project/{slug}/domains'
.replaceAll('{slug}', slug);
// ignore: prefer_final_locals
Object? postBody = projectsDomainsBind;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>['application/json'];
return apiClient.invokeAPI(
path,
'POST',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// Attaches one or more CUSTOM public hostnames to this org's site.
///
/// Attaches one or more CUSTOM public hostnames to this org's site. Binding a host you do not own would let you shadow it at the edge, so which outcome you get depends on whether ownership is already established: a SuperAdmin vouches (the operator manages the customer's DNS, so its bind IS the proof) and binds VERIFIED immediately; every other caller, INCLUDING an admin of the deployment's own brand org, has the host CLAIMED as pending and gets the DNS challenge back in `bound[].records`. A pending claim HOLDS the name so nobody else can take it, but it does not route until POST .../domains/{host}/verify proves control. A hostname we operate is refused to a non-vouched caller (those are assigned by the platform, never claimed), a host another site already holds is a 409, and a name the platform holds is a 400 for EVERY caller — a vouch skips the ownership proof, never the host table's own invariant. Claims and binds are idempotent for the same (org, slug), and re-claiming returns the SAME token rather than invalidating a record the customer has already published. The edge cache-tag is flushed afterwards so a newly-verified host serves the current build immediately. Scope: a validated principal is required (403 without one) and the site is resolved within that principal's org, so another tenant's slug is a 404.
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the site the hosts attach to, from the path.
///
/// * [ProjectsDomainsBind] projectsDomainsBind (required):
Future<ProjectsBoundDomains?> postProjectBySlugDomains(String slug, ProjectsDomainsBind projectsDomainsBind,) async {
final response = await postProjectBySlugDomainsWithHttpInfo(slug, projectsDomainsBind,);
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
// When a remote server returns no body with a status of 204, we shall not decode it.
// At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
// FormatException when trying to decode an empty string.
if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
return await apiClient.deserializeAsync(await _decodeBodyBytes(response), 'ProjectsBoundDomains',) as ProjectsBoundDomains;
}
return null;
}
/// Checks the DNS challenge for a pending custom hostname and, when it passes, promotes the host so it begins routing at the edge.
///
/// Checks the DNS challenge for a pending custom hostname and, when it passes, promotes the host so it begins routing at the edge. It answers 200 either way, with the host's honest current state: verified once the TXT record is found, still pending — with the records to publish and the resolver's own explanation in `detail` — when it is not. A not-yet is not an error: the check ran, DNS simply has not propagated, and the customer retries. An already-verified host is returned unchanged without re-resolving. On a successful promotion the edge cache-tag is flushed, since the host routes as of that moment. Scope: a validated principal is required (403 without one). Both the site and the claim are resolved within that principal's org, so a host claimed by another tenant is \"not claimed by this site\".
///
/// Note: This method returns the HTTP [Response].
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project the host is attached to, from the path.
///
/// * [String] host (required):
/// Host is the custom hostname, from the path. It is cleaned to its canonical form (lowercased, trailing dot dropped) before anything is looked up.
Future<Response> postProjectBySlugDomainsByHostVerifyWithHttpInfo(String slug, String host,) async {
// ignore: prefer_const_declarations
final path = r'/v1/project/{slug}/domains/{host}/verify'
.replaceAll('{slug}', slug)
.replaceAll('{host}', host);
// ignore: prefer_final_locals
Object? postBody;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>[];
return apiClient.invokeAPI(
path,
'POST',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// Checks the DNS challenge for a pending custom hostname and, when it passes, promotes the host so it begins routing at the edge.
///
/// Checks the DNS challenge for a pending custom hostname and, when it passes, promotes the host so it begins routing at the edge. It answers 200 either way, with the host's honest current state: verified once the TXT record is found, still pending — with the records to publish and the resolver's own explanation in `detail` — when it is not. A not-yet is not an error: the check ran, DNS simply has not propagated, and the customer retries. An already-verified host is returned unchanged without re-resolving. On a successful promotion the edge cache-tag is flushed, since the host routes as of that moment. Scope: a validated principal is required (403 without one). Both the site and the claim are resolved within that principal's org, so a host claimed by another tenant is \"not claimed by this site\".
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project the host is attached to, from the path.
///
/// * [String] host (required):
/// Host is the custom hostname, from the path. It is cleaned to its canonical form (lowercased, trailing dot dropped) before anything is looked up.
Future<ProjectsDomain?> postProjectBySlugDomainsByHostVerify(String slug, String host,) async {
final response = await postProjectBySlugDomainsByHostVerifyWithHttpInfo(slug, host,);
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
// When a remote server returns no body with a status of 204, we shall not decode it.
// At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
// FormatException when trying to decode an empty string.
if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
return await apiClient.deserializeAsync(await _decodeBodyBytes(response), 'ProjectsDomain',) as ProjectsDomain;
}
return null;
}
/// Promotes a build output into a new release AND goes live with it — create+activate in one call, which is the 99% path.
///
/// Promotes a build output into a new release AND goes live with it — create+activate in one call, which is the 99% path. It is exactly the two halves in sequence with no extra semantics, so the staged flow and the one-shot flow can never drift apart: `source` is promoted under the same org-relative rule and the same guards CreateRelease applies, then the site's pointer is flipped to it, the public host is claimed and the edge is purged. Idempotent on unchanged bytes — same manifest, same release id, no copy — and billed once, after the release exists. Scope: a validated principal is required (403 without one) and the site is resolved within that principal's org, so another tenant's slug is a 404.
///
/// Note: This method returns the HTTP [Response].
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the site to publish, from the path.
///
/// * [ProjectsPublish] projectsPublish (required):
Future<Response> postProjectBySlugPublishWithHttpInfo(String slug, ProjectsPublish projectsPublish,) async {
// ignore: prefer_const_declarations
final path = r'/v1/project/{slug}/publish'
.replaceAll('{slug}', slug);
// ignore: prefer_final_locals
Object? postBody = projectsPublish;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>['application/json'];
return apiClient.invokeAPI(
path,
'POST',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// Promotes a build output into a new release AND goes live with it — create+activate in one call, which is the 99% path.
///
/// Promotes a build output into a new release AND goes live with it — create+activate in one call, which is the 99% path. It is exactly the two halves in sequence with no extra semantics, so the staged flow and the one-shot flow can never drift apart: `source` is promoted under the same org-relative rule and the same guards CreateRelease applies, then the site's pointer is flipped to it, the public host is claimed and the edge is purged. Idempotent on unchanged bytes — same manifest, same release id, no copy — and billed once, after the release exists. Scope: a validated principal is required (403 without one) and the site is resolved within that principal's org, so another tenant's slug is a 404.
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the site to publish, from the path.
///
/// * [ProjectsPublish] projectsPublish (required):
Future<ProjectsRelease?> postProjectBySlugPublish(String slug, ProjectsPublish projectsPublish,) async {
final response = await postProjectBySlugPublishWithHttpInfo(slug, projectsPublish,);
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
// When a remote server returns no body with a status of 204, we shall not decode it.
// At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
// FormatException when trying to decode an empty string.
if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
return await apiClient.deserializeAsync(await _decodeBodyBytes(response), 'ProjectsRelease',) as ProjectsRelease;
}
return null;
}
/// Flushes the site's edge cache without redeploying anything.
///
/// Flushes the site's edge cache without redeploying anything. It invalidates the edge cache-tag `site-<org>-<slug>` and stamps `lastPurgeAt` (unix seconds), and it NEVER writes or deletes the S3 origin — the live build keeps serving; only stale copies held at the edge drop, so the next request re-fetches the current artifact from origin. Idempotent, and an edge that is unconfigured or failing is not fatal: `lastPurgeAt` is still stamped and the answer is still the updated project. Scope: a validated principal is required (403 without one) and the project is resolved within that principal's org, so another tenant's slug is a 404.
///
/// Note: This method returns the HTTP [Response].
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project to act on, from the path. It is unique within the caller's org and nowhere else, so another tenant's slug is a 404.
Future<Response> postProjectBySlugPurgeWithHttpInfo(String slug,) async {
// ignore: prefer_const_declarations
final path = r'/v1/project/{slug}/purge'
.replaceAll('{slug}', slug);
// ignore: prefer_final_locals
Object? postBody;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>[];
return apiClient.invokeAPI(
path,
'POST',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// Flushes the site's edge cache without redeploying anything.
///
/// Flushes the site's edge cache without redeploying anything. It invalidates the edge cache-tag `site-<org>-<slug>` and stamps `lastPurgeAt` (unix seconds), and it NEVER writes or deletes the S3 origin — the live build keeps serving; only stale copies held at the edge drop, so the next request re-fetches the current artifact from origin. Idempotent, and an edge that is unconfigured or failing is not fatal: `lastPurgeAt` is still stamped and the answer is still the updated project. Scope: a validated principal is required (403 without one) and the project is resolved within that principal's org, so another tenant's slug is a 404.
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project to act on, from the path. It is unique within the caller's org and nowhere else, so another tenant's slug is a 404.
Future<ProjectsProject?> postProjectBySlugPurge(String slug,) async {
final response = await postProjectBySlugPurgeWithHttpInfo(slug,);
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
// When a remote server returns no body with a status of 204, we shall not decode it.
// At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
// FormatException when trying to decode an empty string.
if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
return await apiClient.deserializeAsync(await _decodeBodyBytes(response), 'ProjectsProject',) as ProjectsProject;
}
return null;
}
/// Promotes a build output into a new immutable release WITHOUT serving it — the staged half of publishing, for when you want to check a release before it goes live.
///
/// Promotes a build output into a new immutable release WITHOUT serving it — the staged half of publishing, for when you want to check a release before it goes live. Answers 201. `source` is a path RELATIVE to your org's own storage space: the org segment is prepended server-side from the validated principal and the bucket is never in the request at all, so a server-side copy can only ever reach bytes your org already owns. The prefix is listed, content-addressed (SHA-256 over the sorted manifest of key/size/etag), and copied into an immutable `<org>/.releases/<slug>/<id>/` prefix; the row is written LAST, so a partial copy is unreachable rather than merely unlikely. Re-publishing an unchanged source is idempotent BY CONSTRUCTION — same bytes, same id, no copy at all. The source must contain index.html at its root and stay under the same file and byte caps an artifact deploy does (413 past them); a source that changes mid-copy is a 409 and the release is abandoned. Each publish also reclaims releases past the retention depth, so a site's release space stays bounded. This is the billable half — the hosting gate runs before any copy, and the debit lands once the release exists. Scope: a validated principal is required (403 without one) and the site is resolved within that principal's org, so another tenant's slug is a 404.
///
/// Note: This method returns the HTTP [Response].
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the site to publish, from the path.
///
/// * [ProjectsPublish] projectsPublish (required):
Future<Response> postProjectBySlugReleasesWithHttpInfo(String slug, ProjectsPublish projectsPublish,) async {
// ignore: prefer_const_declarations
final path = r'/v1/project/{slug}/releases'
.replaceAll('{slug}', slug);
// ignore: prefer_final_locals
Object? postBody = projectsPublish;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>['application/json'];
return apiClient.invokeAPI(
path,
'POST',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// Promotes a build output into a new immutable release WITHOUT serving it — the staged half of publishing, for when you want to check a release before it goes live.
///
/// Promotes a build output into a new immutable release WITHOUT serving it — the staged half of publishing, for when you want to check a release before it goes live. Answers 201. `source` is a path RELATIVE to your org's own storage space: the org segment is prepended server-side from the validated principal and the bucket is never in the request at all, so a server-side copy can only ever reach bytes your org already owns. The prefix is listed, content-addressed (SHA-256 over the sorted manifest of key/size/etag), and copied into an immutable `<org>/.releases/<slug>/<id>/` prefix; the row is written LAST, so a partial copy is unreachable rather than merely unlikely. Re-publishing an unchanged source is idempotent BY CONSTRUCTION — same bytes, same id, no copy at all. The source must contain index.html at its root and stay under the same file and byte caps an artifact deploy does (413 past them); a source that changes mid-copy is a 409 and the release is abandoned. Each publish also reclaims releases past the retention depth, so a site's release space stays bounded. This is the billable half — the hosting gate runs before any copy, and the debit lands once the release exists. Scope: a validated principal is required (403 without one) and the site is resolved within that principal's org, so another tenant's slug is a 404.
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the site to publish, from the path.
///
/// * [ProjectsPublish] projectsPublish (required):
Future<ProjectsRelease?> postProjectBySlugReleases(String slug, ProjectsPublish projectsPublish,) async {
final response = await postProjectBySlugReleasesWithHttpInfo(slug, projectsPublish,);
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
// When a remote server returns no body with a status of 204, we shall not decode it.
// At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
// FormatException when trying to decode an empty string.
if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
return await apiClient.deserializeAsync(await _decodeBodyBytes(response), 'ProjectsRelease',) as ProjectsRelease;
}
return null;
}
/// Points the site at an existing release — the go-live, and equally the ROLLBACK.
///
/// Points the site at an existing release — the go-live, and equally the ROLLBACK. Aim it at an older release and the site serves that one again: releases are immutable and retained to the retention depth, so nothing is rebuilt or re-copied and the flip is one atomic statement. Before the flip, two conditions run in the order that gives each its own honest answer — the ROW says whether this release exists for this tenant at all (404, with no signal about a foreign id), and only then do the BYTES say whether it can still serve (410 GONE when retention has reclaimed them; that rollback target is not coming back, so publish again). Going live also claims the public host and purges the edge, so the release is reachable and no cached predecessor is served. NOT billed: no new content is produced, only a pointer moved. Scope: a validated principal is required (403 without one) and the site is resolved within that principal's org, so another tenant's slug is a 404.
///
/// Note: This method returns the HTTP [Response].
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the site the release belongs to, from the path.
///
/// * [String] release (required):
/// Release is the content-addressed release id (\"rel_\" + 32 hex chars), from the path. Anything that is not that shape is not found, rather than being interpolated into a storage prefix.
Future<Response> postProjectBySlugReleasesByReleaseActivateWithHttpInfo(String slug, String release,) async {
// ignore: prefer_const_declarations
final path = r'/v1/project/{slug}/releases/{release}/activate'
.replaceAll('{slug}', slug)
.replaceAll('{release}', release);
// ignore: prefer_final_locals
Object? postBody;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>[];
return apiClient.invokeAPI(
path,
'POST',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// Points the site at an existing release — the go-live, and equally the ROLLBACK.
///
/// Points the site at an existing release — the go-live, and equally the ROLLBACK. Aim it at an older release and the site serves that one again: releases are immutable and retained to the retention depth, so nothing is rebuilt or re-copied and the flip is one atomic statement. Before the flip, two conditions run in the order that gives each its own honest answer — the ROW says whether this release exists for this tenant at all (404, with no signal about a foreign id), and only then do the BYTES say whether it can still serve (410 GONE when retention has reclaimed them; that rollback target is not coming back, so publish again). Going live also claims the public host and purges the edge, so the release is reachable and no cached predecessor is served. NOT billed: no new content is produced, only a pointer moved. Scope: a validated principal is required (403 without one) and the site is resolved within that principal's org, so another tenant's slug is a 404.
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the site the release belongs to, from the path.
///
/// * [String] release (required):
/// Release is the content-addressed release id (\"rel_\" + 32 hex chars), from the path. Anything that is not that shape is not found, rather than being interpolated into a storage prefix.
Future<ProjectsRelease?> postProjectBySlugReleasesByReleaseActivate(String slug, String release,) async {
final response = await postProjectBySlugReleasesByReleaseActivateWithHttpInfo(slug, release,);
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
// When a remote server returns no body with a status of 204, we shall not decode it.
// At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
// FormatException when trying to decode an empty string.
if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
return await apiClient.deserializeAsync(await _decodeBodyBytes(response), 'ProjectsRelease',) as ProjectsRelease;
}
return null;
}
/// Creates a project seeded from a PUBLISHED EXAMPLE — either a starter-kit template from the ONE embedded gallery catalog, or any live project on the platform (an example a seeded creator published, or another org's app serving at <slug>.hanzo.app).
///
/// Creates a project seeded from a PUBLISHED EXAMPLE — either a starter-kit template from the ONE embedded gallery catalog, or any live project on the platform (an example a seeded creator published, or another org's app serving at <slug>.hanzo.app). Answers 201 with the new project. `slug` names the PARENT to fork and is required. Templates resolve first, and the caller org's own private templates ahead of the public gallery, so a curated template slug keeps meaning the same thing even if someone later publishes a live project under it; `variant` picks that template's format/page/theme. If no template matches, the slug resolves to the UNIQUE live project that owns it across all orgs — the same resolution the site edge uses to serve <slug>.hanzo.app, so what you can browse is what you can fork. `name` and `target` override the derived project name and slug; everything else is inherited from the parent. A live parent contributes its REPO, so the child builds from the same source — the parent's deployed bytes are never copied, because releases are per-tenant by design and the fork publishes its own. The parent it actually resolved is stamped on the child as `forkedFrom`, so attribution is a fact recorded at fork time rather than a claim reconstructed later. It funnels through the SAME create path POST /v1/project uses, so slug validation, org scoping, ID minting and the 409 on a slug the caller's own org already uses are identical. Scope: a validated principal is required (403 without one) and the child is created in THAT principal's org.
///
/// Note: This method returns the HTTP [Response].
///
/// Parameters:
///
/// * [ProjectsFork] projectsFork (required):
Future<Response> postProjectForkWithHttpInfo(ProjectsFork projectsFork,) async {
// ignore: prefer_const_declarations
final path = r'/v1/project/fork';
// ignore: prefer_final_locals
Object? postBody = projectsFork;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>['application/json'];
return apiClient.invokeAPI(
path,
'POST',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// Creates a project seeded from a PUBLISHED EXAMPLE — either a starter-kit template from the ONE embedded gallery catalog, or any live project on the platform (an example a seeded creator published, or another org's app serving at <slug>.hanzo.app).
///
/// Creates a project seeded from a PUBLISHED EXAMPLE — either a starter-kit template from the ONE embedded gallery catalog, or any live project on the platform (an example a seeded creator published, or another org's app serving at <slug>.hanzo.app). Answers 201 with the new project. `slug` names the PARENT to fork and is required. Templates resolve first, and the caller org's own private templates ahead of the public gallery, so a curated template slug keeps meaning the same thing even if someone later publishes a live project under it; `variant` picks that template's format/page/theme. If no template matches, the slug resolves to the UNIQUE live project that owns it across all orgs — the same resolution the site edge uses to serve <slug>.hanzo.app, so what you can browse is what you can fork. `name` and `target` override the derived project name and slug; everything else is inherited from the parent. A live parent contributes its REPO, so the child builds from the same source — the parent's deployed bytes are never copied, because releases are per-tenant by design and the fork publishes its own. The parent it actually resolved is stamped on the child as `forkedFrom`, so attribution is a fact recorded at fork time rather than a claim reconstructed later. It funnels through the SAME create path POST /v1/project uses, so slug validation, org scoping, ID minting and the 409 on a slug the caller's own org already uses are identical. Scope: a validated principal is required (403 without one) and the child is created in THAT principal's org.
///
/// Parameters:
///
/// * [ProjectsFork] projectsFork (required):
Future<ProjectsProject?> postProjectFork(ProjectsFork projectsFork,) async {
final response = await postProjectForkWithHttpInfo(projectsFork,);
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
// When a remote server returns no body with a status of 204, we shall not decode it.
// At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
// FormatException when trying to decode an empty string.
if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
return await apiClient.deserializeAsync(await _decodeBodyBytes(response), 'ProjectsProject',) as ProjectsProject;
}
return null;
}
/// Generates a self-contained, mobile-responsive static site from a natural-language brief and deploys it live in one call.
///
/// Generates a self-contained, mobile-responsive static site from a natural-language brief and deploys it live in one call. One inference call turns `brief` (capped at 8 KiB) into a file manifest, which then runs through the SAME validation, guards and viewport guarantee as a hand-supplied manifest: index.html required at the root, absolute and traversal paths rejected, per-file and total size capped, and a mobile viewport meta tag injected into every HTML document that lacks one. The generated site is fully inline — no CDNs, no remote fonts or images — so it is CSP-safe. `slug` and `name` are optional: the model's own title is preferred, and a slug is derived or minted when none is given. It writes into the SAME org-scoped store as /v1/project — it ensures a project (framework `static`) for the resolved slug and records a deployment — so this is a second entry point to one publish pipeline, not a second copy of project state. Ordering is the billing contract: the hosting gate runs BEFORE any inference or upload, so a denied gate generates and uploads NOTHING, and the debit lands once, only after the site is actually live. The tokens are billed to the same ledger the hosting fee was reserved against. Answers 503 when object storage or inference is unconfigured, and 400 when the model's manifest cannot be parsed or fails the guards. Scope: a validated principal is required (403 without one) and the site is published into THAT principal's org.
///
/// Note: This method returns the HTTP [Response].
///
/// Parameters:
///
/// * [ProjectsBuildSite] projectsBuildSite (required):
Future<Response> postProjectSitesWithHttpInfo(ProjectsBuildSite projectsBuildSite,) async {
// ignore: prefer_const_declarations
final path = r'/v1/project/sites';
// ignore: prefer_final_locals
Object? postBody = projectsBuildSite;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>['application/json'];
return apiClient.invokeAPI(
path,
'POST',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// Generates a self-contained, mobile-responsive static site from a natural-language brief and deploys it live in one call.
///
/// Generates a self-contained, mobile-responsive static site from a natural-language brief and deploys it live in one call. One inference call turns `brief` (capped at 8 KiB) into a file manifest, which then runs through the SAME validation, guards and viewport guarantee as a hand-supplied manifest: index.html required at the root, absolute and traversal paths rejected, per-file and total size capped, and a mobile viewport meta tag injected into every HTML document that lacks one. The generated site is fully inline — no CDNs, no remote fonts or images — so it is CSP-safe. `slug` and `name` are optional: the model's own title is preferred, and a slug is derived or minted when none is given. It writes into the SAME org-scoped store as /v1/project — it ensures a project (framework `static`) for the resolved slug and records a deployment — so this is a second entry point to one publish pipeline, not a second copy of project state. Ordering is the billing contract: the hosting gate runs BEFORE any inference or upload, so a denied gate generates and uploads NOTHING, and the debit lands once, only after the site is actually live. The tokens are billed to the same ledger the hosting fee was reserved against. Answers 503 when object storage or inference is unconfigured, and 400 when the model's manifest cannot be parsed or fails the guards. Scope: a validated principal is required (403 without one) and the site is published into THAT principal's org.
///
/// Parameters:
///
/// * [ProjectsBuildSite] projectsBuildSite (required):
Future<ProjectsSiteDeploy?> postProjectSites(ProjectsBuildSite projectsBuildSite,) async {
final response = await postProjectSitesWithHttpInfo(projectsBuildSite,);
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
// When a remote server returns no body with a status of 204, we shall not decode it.
// At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
// FormatException when trying to decode an empty string.
if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
return await apiClient.deserializeAsync(await _decodeBodyBytes(response), 'ProjectsSiteDeploy',) as ProjectsSiteDeploy;
}
return null;
}
/// Deploys a caller-supplied file manifest — the deploy_site capability an agent calls — and answers with where it went live.
///
/// Deploys a caller-supplied file manifest — the deploy_site capability an agent calls — and answers with where it went live. `files` is a list of {path, content} pairs, the same shape the brief build emits, and it runs through the SAME guards: index.html required at the root, absolute and traversal paths rejected, per-file and total size capped, and a mobile viewport meta tag injected into every HTML document that lacks one — so a hand-built site is exactly as safe and as responsive as a generated one. `slug` and `name` are optional; a slug is derived from the name or minted. It writes into the SAME org-scoped store as /v1/project, ensuring a project (framework `static`) for the resolved slug and recording a deployment. The hosting gate runs before the upload and the debit lands once, after the site is live — a failed upload is never billed. Answers 503 when object storage is unconfigured. Scope: a validated principal is required (403 without one) and the site is published into THAT principal's org.
///
/// Note: This method returns the HTTP [Response].
///
/// Parameters:
///
/// * [ProjectsDeploySite] projectsDeploySite (required):
Future<Response> postProjectSitesDeployWithHttpInfo(ProjectsDeploySite projectsDeploySite,) async {
// ignore: prefer_const_declarations
final path = r'/v1/project/sites/deploy';
// ignore: prefer_final_locals
Object? postBody = projectsDeploySite;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>['application/json'];
return apiClient.invokeAPI(
path,
'POST',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// Deploys a caller-supplied file manifest — the deploy_site capability an agent calls — and answers with where it went live.
///
/// Deploys a caller-supplied file manifest — the deploy_site capability an agent calls — and answers with where it went live. `files` is a list of {path, content} pairs, the same shape the brief build emits, and it runs through the SAME guards: index.html required at the root, absolute and traversal paths rejected, per-file and total size capped, and a mobile viewport meta tag injected into every HTML document that lacks one — so a hand-built site is exactly as safe and as responsive as a generated one. `slug` and `name` are optional; a slug is derived from the name or minted. It writes into the SAME org-scoped store as /v1/project, ensuring a project (framework `static`) for the resolved slug and recording a deployment. The hosting gate runs before the upload and the debit lands once, after the site is live — a failed upload is never billed. Answers 503 when object storage is unconfigured. Scope: a validated principal is required (403 without one) and the site is published into THAT principal's org.
///
/// Parameters:
///
/// * [ProjectsDeploySite] projectsDeploySite (required):
Future<ProjectsSiteDeploy?> postProjectSitesDeploy(ProjectsDeploySite projectsDeploySite,) async {
final response = await postProjectSitesDeployWithHttpInfo(projectsDeploySite,);
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
// When a remote server returns no body with a status of 204, we shall not decode it.
// At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
// FormatException when trying to decode an empty string.
if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
return await apiClient.deserializeAsync(await _decodeBodyBytes(response), 'ProjectsSiteDeploy',) as ProjectsSiteDeploy;
}
return null;
}
/// Bookmarks a project for the person calling, and answers whether it is starred afterwards.
///
/// Bookmarks a project for the person calling, and answers whether it is starred afterwards. The star is YOURS: it is keyed by you as well as by the project, so two people see two answers for the same one and starring it says nothing about anybody else's list. Starring a project you have already starred leaves it starred.
///
/// Note: This method returns the HTTP [Response].
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project to act on, from the path. It is unique within the caller's org and nowhere else, so another tenant's slug is a 404.
Future<Response> putProjectBySlugStarWithHttpInfo(String slug,) async {
// ignore: prefer_const_declarations
final path = r'/v1/project/{slug}/star'
.replaceAll('{slug}', slug);
// ignore: prefer_final_locals
Object? postBody;
final queryParams = <QueryParam>[];
final headerParams = <String, String>{};
final formParams = <String, String>{};
const contentTypes = <String>[];
return apiClient.invokeAPI(
path,
'PUT',
queryParams,
postBody,
headerParams,
formParams,
contentTypes.isEmpty ? null : contentTypes.first,
);
}
/// Bookmarks a project for the person calling, and answers whether it is starred afterwards.
///
/// Bookmarks a project for the person calling, and answers whether it is starred afterwards. The star is YOURS: it is keyed by you as well as by the project, so two people see two answers for the same one and starring it says nothing about anybody else's list. Starring a project you have already starred leaves it starred.
///
/// Parameters:
///
/// * [String] slug (required):
/// Slug is the project to act on, from the path. It is unique within the caller's org and nowhere else, so another tenant's slug is a 404.
Future<ProjectsStar?> putProjectBySlugStar(String slug,) async {
final response = await putProjectBySlugStarWithHttpInfo(slug,);
if (response.statusCode >= HttpStatus.badRequest) {
throw ApiException(response.statusCode, await _decodeBodyBytes(response));
}
// When a remote server returns no body with a status of 204, we shall not decode it.
// At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
// FormatException when trying to decode an empty string.
if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
return await apiClient.deserializeAsync(await _decodeBodyBytes(response), 'ProjectsStar',) as ProjectsStar;
}
return null;
}
}
Reference in New Issue View Git Blame Copy Permalink