> ## Documentation Index
> Fetch the complete documentation index at: https://docs.bijection.com/llms.txt
> Use this file to discover all available pages before exploring further.

# bijection connection

> Configure private provider connections and account authorization

## bijection connection

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Deployment-owned connections and provider accounts keep separate authority. Configure records a deployment connection. Authorize performs the declared provider account consent flow; it does not grant deployment administration.

Usage:
  bijection connection [flags]
  bijection connection [command]

Available Commands:
  activate               Activate a connection after its credential roles are bound
  authorization-status   Inspect durable authorization completion without replaying its code
  authorize              Authorize a provider account for its declared owner
  bind-authorization     Import a provider grant into managed account custody
  browser                Interact with an account sign-in browser
  callback               Complete an authorization started by account-authorize
  configure              Configure a deployment-owned connection
  create                 Connect an account and select what it may read
  credential             Manage private credentials without displaying their bytes
  disconnect             Withdraw a connection's authorization and keep its data
  erase                  Erase a disconnected connection's imported data
  executor               Connect and inspect a customer-owned analytical executor
  inspect                Inspect connection state and remote revocation
  list                   List authorized integration connections
  pause                  Stop a connection's acquisition and keep its data
  resources              Read one replayable native resource page
  resume                 Resume a paused connection's acquisition
  retire                 Retire a deployment-owned connection
  revoke-provider-access Review and withdraw provider access across the affected account contexts
  role-bind              Bind a private credential role
  select-resource        Verify an account resource for application installation
  status                 Inspect connection authority and acquisition
  verify                 Admit exact connection verification work

Flags:
  -h, --help        help for connection
      --help-all    Show all commands and options, including administrative controls.
      --help-json   Print command input and output schemas as JSON without executing it.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.

Use "bijection connection [command] --help" for more information about a command.
```

## bijection connection activate

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Activate a connection after its credential roles are bound

Usage:
  bijection connection activate <destination> [flags]

Flags:
      --deployment string   Activate a configured connection once it holds every credential role its definition names on a specific deployment. Accepts:
                            • a deployment name (e.g. joyful-capybara-123)
                            • a deployment reference (e.g. dev/james, staging)
                            • dev (for your personal dev deployment)
                            • prod (for your project’s default production deployment).
                            You can also select deployments in other projects with project-slug:reference.
  -h, --help                help for activate
      --help-all            Show all commands and options, including administrative controls.
      --help-json           Print command input and output schemas as JSON without executing it.
      --url string          Activate a configured connection once it holds every credential role its definition names on a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection authorization-status

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Inspect durable authorization completion without replaying its code

Usage:
  bijection connection authorization-status [flags]

Flags:
      --account-user string   Application user to act for with administrative credentials
      --as string             Act as a person, such as alice, on a development, preview or local deployment. Production refuses development identities.
      --attempt string        Opaque authorization attempt
      --deployment string     Inspect authorization on a specific deployment. Accepts:
                              • a deployment name (e.g. joyful-capybara-123)
                              • a deployment reference (e.g. dev/james, staging)
                              • dev (for your personal dev deployment)
                              • prod (for your project’s default production deployment).
                              You can also select deployments in other projects with project-slug:reference.
      --format string         Output format; JSON preserves exact values. (pretty, json) (default "pretty")
  -h, --help                  help for authorization-status
      --help-all              Show all commands and options, including administrative controls.
      --help-json             Print command input and output schemas as JSON without executing it.
      --url string            Inspect authorization on a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection authorize

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
The provider grants what it chooses, which may be less than was asked. A single-use authorization code is never printed or stored.
Which setup values a connecting account supplies is declared on the integration definition; a provider whose authorization endpoint is per-instance needs them before consent. Deployment configuration is not supplied here, and neither is a secret.

Usage:
  bijection connection authorize [flags]

Flags:
      --account string        Reconnect this existing account instead of adding one
      --account-user string   Application user owning the account, as its token identifier (issuer|subject)
      --as string             Act as a person, such as alice, on a development, preview or local deployment. Production refuses development identities.
      --code string           Complete without prompting; for scripts that already hold the redirect
      --component string      Component path; defaults to root
      --deployment string     Connect a provider account for an application user on a specific deployment. Accepts:
                              • a deployment name (e.g. joyful-capybara-123)
                              • a deployment reference (e.g. dev/james, staging)
                              • dev (for your personal dev deployment)
                              • prod (for your project’s default production deployment).
                              You can also select deployments in other projects with project-slug:reference.
      --export string         Defining integration export
  -h, --help                  help for account-authorize
      --help-all              Show all commands and options, including administrative controls.
      --help-json             Print command input and output schemas as JSON without executing it.
      --module string         Defining deployed module, including .js
      --organization string   Organization context for provider settings
      --owner string          Connection owner: personal or organization
      --permission string     Required provider permission; repeat for several (default "[]")
      --redirect-uri string   Where the provider returns the user after consent
      --setup string          A setup value this provider's definition asks the connecting account for; repeatable (default "[]")
      --url string            Connect a provider account for an application user on a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection bind-authorization

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Import a provider grant into managed account custody

Usage:
  bijection connection bind-authorization <connection> [flags]

Flags:
      --capability string      Required provider capability; repeatable (default "[]")
      --deployment string      Bind managed provider authorization on a specific deployment. Accepts:
                               • a deployment name (e.g. joyful-capybara-123)
                               • a deployment reference (e.g. dev/james, staging)
                               • dev (for your personal dev deployment)
                               • prod (for your project’s default production deployment).
                               You can also select deployments in other projects with project-slug:reference.
      --from-file string       Read the private credential envelope; otherwise read piped stdin
  -h, --help                   help for bind-authorization
      --help-all               Show all commands and options, including administrative controls.
      --help-json              Print command input and output schemas as JSON without executing it.
      --identity-url string    Provider profile endpoint admitted by the grant
      --request-id string      Stable ID retained across retries of this exact import
      --subject-field string   Profile field identifying the provider principal (default "sub")
      --url string             Bind managed provider authorization on a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection browser

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Interact with an account sign-in browser

Usage:
  bijection connection browser [flags]

Flags:
      --account-user string   Explicit account subject for an administrative call
      --as string             Act as a person, such as alice, on a development, preview or local deployment. Production refuses development identities.
      --attempt string        Attempt reported by account-authorize
      --deployment string     Interact with an account sign-in browser on a specific deployment. Accepts:
                              • a deployment name (e.g. joyful-capybara-123)
                              • a deployment reference (e.g. dev/james, staging)
                              • dev (for your personal dev deployment)
                              • prod (for your project’s default production deployment).
                              You can also select deployments in other projects with project-slug:reference.
      --from-file string      Read interaction JSON from this file instead of stdin
  -h, --help                  help for account-browser
      --help-all              Show all commands and options, including administrative controls.
      --help-json             Print command input and output schemas as JSON without executing it.
      --state string          State reported by account-authorize
      --url string            Interact with an account sign-in browser on a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection callback

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Complete an authorization started by account-authorize

Usage:
  bijection connection callback [flags]

Flags:
      --account-user string   Application user owning the account, as its token identifier (issuer|subject)
      --as string             Act as a person, such as alice, on a development, preview or local deployment. Production refuses development identities.
      --attempt string        Attempt reported by account-authorize
      --code string           Single-use code from the provider redirect
      --deployment string     Complete an authorization started by account-authorize on a specific deployment. Accepts:
                              • a deployment name (e.g. joyful-capybara-123)
                              • a deployment reference (e.g. dev/james, staging)
                              • dev (for your personal dev deployment)
                              • prod (for your project’s default production deployment).
                              You can also select deployments in other projects with project-slug:reference.
  -h, --help                  help for account-callback
      --help-all              Show all commands and options, including administrative controls.
      --help-json             Print command input and output schemas as JSON without executing it.
      --state string          State reported by account-authorize
      --url string            Complete an authorization started by account-authorize on a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection configure

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
The integration definition declares required setup values. Use --show-setup to inspect them. Use --interactive for guided setup, --from-file for a private credential, or --input for the complete private configuration. Configuration commits locally; source connect performs durable identity verification and installation.

Usage:
  bijection connection configure [destination] [flags]

Flags:
      --base-url string         Provider base URL; omitted where the address is private configuration
      --component string        Component path; defaults to root
      --credential-ref string   Private default credential; omitted when every HTTP contract uses a named role
      --deployment string       Configure an admitted connection on a specific deployment. Accepts:
                                • a deployment name (e.g. joyful-capybara-123)
                                • a deployment reference (e.g. dev/james, staging)
                                • dev (for your personal dev deployment)
                                • prod (for your project’s default production deployment).
                                You can also select deployments in other projects with project-slug:reference.
      --from-file string        Provision private credential JSON atomically; - reads piped stdin
  -h, --help                    help for configure
      --help-all                Show all commands and options, including administrative controls.
      --help-json               Print command input and output schemas as JSON without executing it.
      --input string            Complete private connection configuration as JSON; - reads piped stdin
      --integration string      Deployed integration declaration
      --interactive             Collect declared setup and private credentials before one atomic configuration
      --setup string            A setup value this provider's definition declares; repeatable (default "[]")
      --setup-json string       Typed native setup as a Bijection JSON object
      --show-setup              Print what this connection has to be told and make no change
      --url string              Configure an admitted connection on a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection create

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Connect an account and select what it may read

Usage:
  bijection connection create <module:export> [flags]

Examples:
  bijection connection create drive:drive

Flags:
      --account string        Exact account when several are available
      --as string             Act as a person, such as alice, on a development, preview or local deployment. Production refuses development identities.
      --code string           Complete an offered redirect in a script
      --component string      Owning component
      --deployment string     Inspect or connect on a specific deployment. Accepts:
                              • a deployment name (e.g. joyful-capybara-123)
                              • a deployment reference (e.g. dev/james, staging)
                              • dev (for your personal dev deployment)
                              • prod (for your project’s default production deployment).
                              You can also select deployments in other projects with project-slug:reference.
  -h, --help                  help for connect
      --help-all              Show all commands and options, including administrative controls.
      --help-json             Print command input and output schemas as JSON without executing it.
      --organization string   Organization context
      --owner string          personal or organization
      --permission string     Required provider permission (default "[]")
      --redirect-uri string   Registered OAuth callback
      --setup string          Declared non-secret account setup (default "[]")
      --url string            Inspect or connect on a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection credential

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Manage private credentials without displaying their bytes

Usage:
  bijection connection credential [flags]
  bijection connection credential [command]

Available Commands:
  create      Create a private integration credential
  inspect     Inspect private credential metadata
  recover     Recover an unknown credential repair without resending its secret
  rotate      Rotate a private credential and repair its captured connections
  set         Replace a connection credential and verify its identity durably

Flags:
  -h, --help        help for credential
      --help-all    Show all commands and options, including administrative controls.
      --help-json   Print command input and output schemas as JSON without executing it.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.

Use "bijection connection credential [command] --help" for more information about a command.
```

## bijection connection credential create

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Input is limited to 8 KiB. All bytes are preserved, including a terminal newline. Use printf instead of echo when no newline is intended. Values are never printed.

Usage:
  bijection connection credential create <name> [flags]

Flags:
      --deployment string   Create a private connection credential on a specific deployment. Accepts:
                            • a deployment name (e.g. joyful-capybara-123)
                            • a deployment reference (e.g. dev/james, staging)
                            • dev (for your personal dev deployment)
                            • prod (for your project’s default production deployment).
                            You can also select deployments in other projects with project-slug:reference.
      --from-file string    Read the exact UTF-8 credential from a file instead of piped stdin
  -h, --help                help for credential-create
      --help-all            Show all commands and options, including administrative controls.
      --help-json           Print command input and output schemas as JSON without executing it.
      --url string          Create a private connection credential on a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection credential inspect

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Inspect private credential metadata

Usage:
  bijection connection credential inspect <name> [flags]

Flags:
      --deployment string    Inspect private credential metadata on a specific deployment. Accepts:
                             • a deployment name (e.g. joyful-capybara-123)
                             • a deployment reference (e.g. dev/james, staging)
                             • dev (for your personal dev deployment)
                             • prod (for your project’s default production deployment).
                             You can also select deployments in other projects with project-slug:reference.
  -h, --help                 help for credential-status
      --help-all             Show all commands and options, including administrative controls.
      --help-json            Print command input and output schemas as JSON without executing it.
      --request-key string   Inspect the exact rotation and each affected connection's repair
      --url string           Inspect private credential metadata on a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection credential recover

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Recover an unknown credential repair without resending its secret

Usage:
  bijection connection credential recover <connection> [flags]

Flags:
      --deployment string   Recover a credential repair on a specific deployment. Accepts:
                            • a deployment name (e.g. joyful-capybara-123)
                            • a deployment reference (e.g. dev/james, staging)
                            • dev (for your personal dev deployment)
                            • prod (for your project’s default production deployment).
                            You can also select deployments in other projects with project-slug:reference.
      --format string       Output format; JSON preserves exact values. (pretty, json) (default "pretty")
  -h, --help                help for recover
      --help-all            Show all commands and options, including administrative controls.
      --help-json           Print command input and output schemas as JSON without executing it.
      --url string          Recover a credential repair on a private deployment at this explicit origin.
      --wait string         Wait for the retained repair (maximum 10m)

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection credential rotate

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Input is limited to 8 KiB. All bytes are preserved, including a terminal newline. Use printf instead of echo when no newline is intended. Values are never printed. Bound connections are verified and resumed through their installed repair controllers. Inspect the same request with connection credential inspect --request-key.

Usage:
  bijection connection credential rotate <name> [flags]

Flags:
      --deployment string    Rotate an existing private connection credential on a specific deployment. Accepts:
                             • a deployment name (e.g. joyful-capybara-123)
                             • a deployment reference (e.g. dev/james, staging)
                             • dev (for your personal dev deployment)
                             • prod (for your project’s default production deployment).
                             You can also select deployments in other projects with project-slug:reference.
      --from-file string     Read the exact UTF-8 credential from a file instead of piped stdin
  -h, --help                 help for credential-rotate
      --help-all             Show all commands and options, including administrative controls.
      --help-json            Print command input and output schemas as JSON without executing it.
      --request-key string   Stable key for this exact rotation; reuse it to recover the same request
      --url string           Rotate an existing private connection credential on a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection credential set

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Replace a connection credential and verify its identity durably

Usage:
  bijection connection credential set <connection> [flags]

Flags:
      --deployment string   Repair a connection credential on a specific deployment. Accepts:
                            • a deployment name (e.g. joyful-capybara-123)
                            • a deployment reference (e.g. dev/james, staging)
                            • dev (for your personal dev deployment)
                            • prod (for your project’s default production deployment).
                            You can also select deployments in other projects with project-slug:reference.
      --format string       Output format; JSON preserves exact values. (pretty, json) (default "pretty")
      --from-file string    Read private UTF-8 bytes; otherwise read piped stdin
  -h, --help                help for set
      --help-all            Show all commands and options, including administrative controls.
      --help-json           Print command input and output schemas as JSON without executing it.
      --url string          Repair a connection credential on a private deployment at this explicit origin.
      --wait string         Wait for verification and source recovery (maximum 10m)

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection disconnect

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Disconnection is terminal for this account. Reconnecting completes a new authorization; it does not revive this one. Acquired records are kept.

Usage:
  bijection connection disconnect <account> [flags]

Flags:
      --account-user string   Application user owning the account, as its token identifier (issuer|subject)
      --as string             Act as a person, such as alice, on a development, preview or local deployment. Production refuses development identities.
      --component string      Component path; defaults to root
      --deployment string     Revoke an account's authority and stop its acquisition on a specific deployment. Accepts:
                              • a deployment name (e.g. joyful-capybara-123)
                              • a deployment reference (e.g. dev/james, staging)
                              • dev (for your personal dev deployment)
                              • prod (for your project’s default production deployment).
                              You can also select deployments in other projects with project-slug:reference.
      --export string         Defining integration export
  -h, --help                  help for account-disconnect
      --help-all              Show all commands and options, including administrative controls.
      --help-json             Print command input and output schemas as JSON without executing it.
      --module string         Defining deployed module, including .js
      --organization string   Organization context for provider settings
      --owner string          Connection owner: personal or organization
      --url string            Revoke an account's authority and stop its acquisition on a private deployment at this explicit origin.
      --yes                   Confirm without prompting

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection erase

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Erasure is permanent and removes acquired records. It does not undo effects already delivered to the provider.

Usage:
  bijection connection erase <account> [flags]

Flags:
      --account-user string   Application user owning the account, as its token identifier (issuer|subject)
      --as string             Act as a person, such as alice, on a development, preview or local deployment. Production refuses development identities.
      --component string      Component path; defaults to root
      --deployment string     Erase an account's sources and everything acquired through them on a specific deployment. Accepts:
                              • a deployment name (e.g. joyful-capybara-123)
                              • a deployment reference (e.g. dev/james, staging)
                              • dev (for your personal dev deployment)
                              • prod (for your project’s default production deployment).
                              You can also select deployments in other projects with project-slug:reference.
      --export string         Defining integration export
  -h, --help                  help for account-erase
      --help-all              Show all commands and options, including administrative controls.
      --help-json             Print command input and output schemas as JSON without executing it.
      --module string         Defining deployed module, including .js
      --organization string   Organization context for provider settings
      --owner string          Connection owner: personal or organization
      --url string            Erase an account's sources and everything acquired through them on a private deployment at this explicit origin.
      --yes                   Confirm without prompting

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection executor

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Connect and inspect a customer-owned analytical executor

Usage:
  bijection connection executor [flags]
  bijection connection executor [command]

Available Commands:
  bindings        Inspect the executor's installed table placements and their revisions
  capture-catalog Capture reviewed ClickHouse table contracts for generated bindings
  discover        Browse a configured customer executor's catalogs, tables and field types
  preflight       Check native executor admission without source refresh or query execution
  probe           Run one bounded constant-only statement on a configured customer executor
  setup           Connect a customer analytical engine using typed engine settings and catalog bindings
  view-status     Inspect ClickHouse refresh observations independently of retained answers

Flags:
  -h, --help        help for executor
      --help-all    Show all commands and options, including administrative controls.
      --help-json   Print command input and output schemas as JSON without executing it.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.

Use "bijection connection executor [command] --help" for more information about a command.
```

## bijection connection executor bindings

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Reads deployment configuration only and contacts no provider. Each remote table's placement has a revision that admitted runs record; a changed placement refuses work prepared under the previous one. The connection revision evidence is what a later setup must match.

Usage:
  bijection connection executor bindings <connection> [flags]

Flags:
      --deployment string   Inspect executor bindings on a specific deployment. Accepts:
                            • a deployment name (e.g. joyful-capybara-123)
                            • a deployment reference (e.g. dev/james, staging)
                            • dev (for your personal dev deployment)
                            • prod (for your project’s default production deployment).
                            You can also select deployments in other projects with project-slug:reference.
      --format string       Output format; JSON preserves exact values. (pretty, json) (default "pretty")
  -h, --help                help for bindings
      --help-all            Show all commands and options, including administrative controls.
      --help-json           Print command input and output schemas as JSON without executing it.
      --url string          Inspect executor bindings on a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection executor capture-catalog

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Capture reviewed ClickHouse table contracts for generated bindings

Usage:
  bijection connection executor capture-catalog <connection> [flags]

Flags:
      --bindings-output string   Write reviewed physical placements for executor setup --tables; aliases name logical schema tables
      --check                    Compare current definitions with the captured artifact without writing
      --deployment string        Capture a ClickHouse catalog on a specific deployment. Accepts:
                                 • a deployment name (e.g. joyful-capybara-123)
                                 • a deployment reference (e.g. dev/james, staging)
                                 • dev (for your personal dev deployment)
                                 • prod (for your project’s default production deployment).
                                 You can also select deployments in other projects with project-slug:reference.
  -h, --help                     help for capture-catalog
      --help-all                 Show all commands and options, including administrative controls.
      --help-json                Print command input and output schemas as JSON without executing it.
      --output string            Captured JSON source contract
      --table string             Explicit approved table selection; repeatable (default "[]")
      --url string               Capture a ClickHouse catalog on a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection executor discover

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Uses the existing SQL metadata owner and private credential reference. Trino and Presto list visible catalogs without --catalog. Select a catalog to list tables, or a fully qualified table to inspect its columns. This is operator display metadata, not query-admission evidence; nothing is acquired or installed.

Usage:
  bijection connection executor discover <connection> [flags]

Flags:
      --catalog string      Provider catalog or database to inspect
      --deployment string   Browse executor metadata on a specific deployment. Accepts:
                            • a deployment name (e.g. joyful-capybara-123)
                            • a deployment reference (e.g. dev/james, staging)
                            • dev (for your personal dev deployment)
                            • prod (for your project’s default production deployment).
                            You can also select deployments in other projects with project-slug:reference.
      --format string       Output format; JSON preserves exact values. (pretty, json) (default "pretty")
  -h, --help                help for discover
      --help-all            Show all commands and options, including administrative controls.
      --help-json           Print command input and output schemas as JSON without executing it.
      --schema string       Table schema; requires --table
      --table string        Inspect one table's field types; requires catalog and schema
      --url string          Browse executor metadata on a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection executor preflight

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Checks the deployed question and its exact arguments using current connection authority, physical metadata and retained input readiness. Prints structured diagnostics and advisory revision evidence. Statement execution and decoding are tested explicitly with connection executor probe.

Usage:
  bijection connection executor preflight <question-or-collection> [args...] [flags]

Flags:
      --args string         Complete declared question arguments as exact JSON or @path
      --as string           Act as a person, such as alice, on a development, preview or local deployment. Production refuses development identities.
      --branch string       Use a branch under your current business identity.
      --deployment string   Inspect definitions in a specific deployment. Accepts:
                            • a deployment name (e.g. joyful-capybara-123)
                            • a deployment reference (e.g. dev/james, staging)
                            • dev (for your personal dev deployment)
                            • prod (for your project’s default production deployment).
                            You can also select deployments in other projects with project-slug:reference.
      --format string       Output format; JSON preserves exact values. (pretty, json) (default "pretty")
  -h, --help                help for preflight
      --help-all            Show all commands and options, including administrative controls.
      --help-json           Print command input and output schemas as JSON without executing it.
      --provider-plan       Explicitly validate the declared compiled statement using EXPLAIN VALIDATE or a BigQuery dry run
      --relation string     A bounded relation over a collection
      --url string          Inspect definitions in a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection executor probe

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Explicitly contacts the customer engine using the configured private credential. Executes one constant SELECT with one result row through the ordinary statement protocol and verifies exact Int64, text and boolean decoding. It reads no customer relation and is advisory, not admission or live-workload qualification.

Usage:
  bijection connection executor probe <connection> [flags]

Flags:
      --deployment string   Probe an executor on a specific deployment. Accepts:
                            • a deployment name (e.g. joyful-capybara-123)
                            • a deployment reference (e.g. dev/james, staging)
                            • dev (for your personal dev deployment)
                            • prod (for your project’s default production deployment).
                            You can also select deployments in other projects with project-slug:reference.
      --format string       Output format; JSON preserves exact values. (pretty, json) (default "pretty")
  -h, --help                help for probe
      --help-all            Show all commands and options, including administrative controls.
      --help-json           Print command input and output schemas as JSON without executing it.
      --url string          Probe an executor on a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection executor setup

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Installs a prepared executor through the ordinary atomic credential and connection owner, with revision-checked declaration and binding setup. Provide coordinator settings and bindings with an existing private credential reference or a token file; no example script or manually assembled private JSON is required. Discovery and native preflight report readiness after installation.

Usage:
  bijection connection executor setup <connection> [flags]

Flags:
      --billing-project string         BigQuery billing project
      --candidate string               Public executor metadata from check --candidate-out; prepare a first connection before activation
      --catalog-binding string         Map a dataset catalog identity to the engine catalog; repeatable (default "[]")
      --credential-ref string          Existing private protocol credential; coordinator settings are still required
      --deployment string              Set up an executor on a specific deployment. Accepts:
                                       • a deployment name (e.g. joyful-capybara-123)
                                       • a deployment reference (e.g. dev/james, staging)
                                       • dev (for your personal dev deployment)
                                       • prod (for your project’s default production deployment).
                                       You can also select deployments in other projects with project-slug:reference.
      --endpoint string                New customer coordinator origin
      --engine string                  Customer engine statement protocol (trino, presto, snowflake, databricks, bigquery, clickhouse) (default "trino")
      --format string                  Output format; JSON preserves exact values. (pretty, json) (default "pretty")
  -h, --help                           help for setup
      --help-all                       Show all commands and options, including administrative controls.
      --help-json                      Print command input and output schemas as JSON without executing it.
      --integration string             Deployed analytical integration declaration
      --integration-component string   Component declaring the integration; defaults to the application root
      --interactive                    Open the local operator setup page; private credentials remain in the CLI process
      --location string                BigQuery location
      --max-bytes-billed string        BigQuery positive exact Int64 billed-byte cap
      --no-open                        Print the interactive setup URL without opening a browser
      --role string                    Optional Snowflake role
      --tables string                  JSON placements of every remote table on this executor (catalog, schema, table, columns); replaces the installed set. Omitted, installed placements are kept
      --token-file string              Private customer token file; never an argument value
      --url string                     Set up an executor on the deployment at the given URL.
      --user string                    Trino, Presto or ClickHouse identity
      --warehouse string               Snowflake warehouse or Databricks warehouse ID

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection executor view-status

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Inspect ClickHouse refresh observations independently of retained answers

Usage:
  bijection connection executor view-status <connection> <database.view> [flags]

Flags:
      --deployment string   Inspect a ClickHouse view on a specific deployment. Accepts:
                            • a deployment name (e.g. joyful-capybara-123)
                            • a deployment reference (e.g. dev/james, staging)
                            • dev (for your personal dev deployment)
                            • prod (for your project’s default production deployment).
                            You can also select deployments in other projects with project-slug:reference.
      --format string       Output format; JSON preserves exact values. (pretty, json) (default "pretty")
  -h, --help                help for view-status
      --help-all            Show all commands and options, including administrative controls.
      --help-json           Print command input and output schemas as JSON without executing it.
      --url string          Inspect a ClickHouse view on a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection inspect

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Inspect connection state and remote revocation

Usage:
  bijection connection inspect <destination> [flags]

Flags:
      --deployment string   Read a connection on a specific deployment. Accepts:
                            • a deployment name (e.g. joyful-capybara-123)
                            • a deployment reference (e.g. dev/james, staging)
                            • dev (for your personal dev deployment)
                            • prod (for your project’s default production deployment).
                            You can also select deployments in other projects with project-slug:reference.
  -h, --help                help for connection-status
      --help-all            Show all commands and options, including administrative controls.
      --help-json           Print command input and output schemas as JSON without executing it.
      --url string          Read a connection on a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection list

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
List authorized integration connections

Usage:
  bijection connection list [module:export] [flags]

Examples:
  bijection connection list drive:drive

Flags:
      --account string        Exact account when several are available
      --as string             Act as a person, such as alice, on a development, preview or local deployment. Production refuses development identities.
      --component string      Owning component
      --cursor string         Continue the exact returned basis
      --deployment string     Inspect or connect on a specific deployment. Accepts:
                              • a deployment name (e.g. joyful-capybara-123)
                              • a deployment reference (e.g. dev/james, staging)
                              • dev (for your personal dev deployment)
                              • prod (for your project’s default production deployment).
                              You can also select deployments in other projects with project-slug:reference.
      --format string         Output format; JSON preserves exact values. (pretty, json) (default "pretty")
  -h, --help                  help for list
      --help-all              Show all commands and options, including administrative controls.
      --help-json             Print command input and output schemas as JSON without executing it.
      --organization string   Organization context
      --owner string          personal or organization
      --url string            Inspect or connect on a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection pause

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Stop a connection's acquisition and keep its data

Usage:
  bijection connection pause <account> [flags]

Flags:
      --account-user string   Application user owning the account, as its token identifier (issuer|subject)
      --as string             Act as a person, such as alice, on a development, preview or local deployment. Production refuses development identities.
      --component string      Component path; defaults to root
      --deployment string     Stop acquisition without surrendering authority on a specific deployment. Accepts:
                              • a deployment name (e.g. joyful-capybara-123)
                              • a deployment reference (e.g. dev/james, staging)
                              • dev (for your personal dev deployment)
                              • prod (for your project’s default production deployment).
                              You can also select deployments in other projects with project-slug:reference.
      --export string         Defining integration export
  -h, --help                  help for account-pause
      --help-all              Show all commands and options, including administrative controls.
      --help-json             Print command input and output schemas as JSON without executing it.
      --module string         Defining deployed module, including .js
      --organization string   Organization context for provider settings
      --owner string          Connection owner: personal or organization
      --url string            Stop acquisition without surrendering authority on a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection resources

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Read one replayable native resource page

Usage:
  bijection connection resources <account> [flags]

Flags:
      --account-user string   Application user owning the account, as its token identifier (issuer|subject)
      --as string             Act as a person, such as alice, on a development, preview or local deployment. Production refuses development identities.
      --component string      Component path; defaults to root
      --cursor string         Native next_cursor from the preceding page
      --deployment string     Read one replayable native resource page on a specific deployment. Accepts:
                              • a deployment name (e.g. joyful-capybara-123)
                              • a deployment reference (e.g. dev/james, staging)
                              • dev (for your personal dev deployment)
                              • prod (for your project’s default production deployment).
                              You can also select deployments in other projects with project-slug:reference.
      --export string         Defining integration export
  -h, --help                  help for account-resources
      --help-all              Show all commands and options, including administrative controls.
      --help-json             Print command input and output schemas as JSON without executing it.
      --module string         Defining deployed module, including .js
      --organization string   Organization context for provider settings
      --owner string          Connection owner: personal or organization
      --request string        Stable identity for this page and its retries
      --url string            Read one replayable native resource page on a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection resume

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Resume a paused connection's acquisition

Usage:
  bijection connection resume <account> [flags]

Flags:
      --account-user string   Application user owning the account, as its token identifier (issuer|subject)
      --as string             Act as a person, such as alice, on a development, preview or local deployment. Production refuses development identities.
      --component string      Component path; defaults to root
      --deployment string     Recreate acquisition for a paused account on a specific deployment. Accepts:
                              • a deployment name (e.g. joyful-capybara-123)
                              • a deployment reference (e.g. dev/james, staging)
                              • dev (for your personal dev deployment)
                              • prod (for your project’s default production deployment).
                              You can also select deployments in other projects with project-slug:reference.
      --export string         Defining integration export
  -h, --help                  help for account-resume
      --help-all              Show all commands and options, including administrative controls.
      --help-json             Print command input and output schemas as JSON without executing it.
      --module string         Defining deployed module, including .js
      --organization string   Organization context for provider settings
      --owner string          Connection owner: personal or organization
      --url string            Recreate acquisition for a paused account on a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection retire

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Retire a deployment-owned connection

Usage:
  bijection connection retire <destination> [flags]

Flags:
      --deployment string   Retire a connection on a specific deployment. Accepts:
                            • a deployment name (e.g. joyful-capybara-123)
                            • a deployment reference (e.g. dev/james, staging)
                            • dev (for your personal dev deployment)
                            • prod (for your project’s default production deployment).
                            You can also select deployments in other projects with project-slug:reference.
  -h, --help                help for retire
      --help-all            Show all commands and options, including administrative controls.
      --help-json           Print command input and output schemas as JSON without executing it.
      --url string          Retire a connection on a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection revoke-provider-access

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Review and withdraw provider access across the affected account contexts

Usage:
  bijection connection revoke-provider-access <account> [flags]

Flags:
      --account-user string   Application user to act for with administrative credentials
      --as string             Act as a person, such as alice, on a development, preview or local deployment. Production refuses development identities.
      --component string      Owning component
      --deployment string     Withdraw provider access on a specific deployment. Accepts:
                              • a deployment name (e.g. joyful-capybara-123)
                              • a deployment reference (e.g. dev/james, staging)
                              • dev (for your personal dev deployment)
                              • prod (for your project’s default production deployment).
                              You can also select deployments in other projects with project-slug:reference.
      --export string         Defining integration export
      --format string         Output format; JSON preserves exact values. (pretty, json) (default "pretty")
  -h, --help                  help for revoke-provider-access
      --help-all              Show all commands and options, including administrative controls.
      --help-json             Print command input and output schemas as JSON without executing it.
      --module string         Defining deployed module
      --organization string   Organization context
      --owner string          personal or organization
      --plan string           Recover the same previously reviewed withdrawal plan
      --preview               Review the affected contexts without requesting provider withdrawal
      --url string            Withdraw provider access on a private deployment at this explicit origin.
      --yes                   Accept the reviewed provider withdrawal plan

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection role-bind

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Input is limited to 8 KiB and is never printed. A role belongs to the connection's authorizing account. Then run bijection connection activate.

Usage:
  bijection connection role-bind <destination> [flags]

Flags:
      --base-url string     Provider HTTP base URL for this role
      --capability string   Capability this role is granted; repeatable (default "[]")
      --deployment string   Bind one credential role of a configured connection on a specific deployment. Accepts:
                            • a deployment name (e.g. joyful-capybara-123)
                            • a deployment reference (e.g. dev/james, staging)
                            • dev (for your personal dev deployment)
                            • prod (for your project’s default production deployment).
                            You can also select deployments in other projects with project-slug:reference.
      --from-file string    Read the exact UTF-8 credential envelope from a file instead of piped stdin
  -h, --help                help for role-bind
      --help-all            Show all commands and options, including administrative controls.
      --help-json           Print command input and output schemas as JSON without executing it.
      --role string         Credential role the definition dispatches under
      --url string          Bind one credential role of a configured connection on a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection select-resource

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Add the named resources to this connection. Manage each installed source with source pause, resume or withdraw.

Usage:
  bijection connection select-resource <account> [flags]

Flags:
      --account-user string   Application user owning the account, as its token identifier (issuer|subject)
      --as string             Act as a person, such as alice, on a development, preview or local deployment. Production refuses development identities.
      --component string      Component path; defaults to root
      --deployment string     Verify an account resource on a specific deployment. Accepts:
                              • a deployment name (e.g. joyful-capybara-123)
                              • a deployment reference (e.g. dev/james, staging)
                              • dev (for your personal dev deployment)
                              • prod (for your project’s default production deployment).
                              You can also select deployments in other projects with project-slug:reference.
      --export string         Defining integration export
  -h, --help                  help for select-resource
      --help-all              Show all commands and options, including administrative controls.
      --help-json             Print command input and output schemas as JSON without executing it.
      --module string         Defining deployed module, including .js
      --organization string   Organization context for provider settings
      --owner string          Connection owner: personal or organization
      --proof string          The resource's native discovery proof
      --resource string       One resource handle from a native page
      --url string            Verify an account resource on a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection status

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Inspect connection authority and acquisition

Usage:
  bijection connection status <account> [flags]

Flags:
      --account-user string   Application user owning the account, as its token identifier (issuer|subject)
      --as string             Act as a person, such as alice, on a development, preview or local deployment. Production refuses development identities.
      --component string      Component path; defaults to root
      --deployment string     Inspect account state, capabilities and sources on a specific deployment. Accepts:
                              • a deployment name (e.g. joyful-capybara-123)
                              • a deployment reference (e.g. dev/james, staging)
                              • dev (for your personal dev deployment)
                              • prod (for your project’s default production deployment).
                              You can also select deployments in other projects with project-slug:reference.
      --export string         Defining integration export
      --format string         Output format; JSON preserves exact values. (pretty, json) (default "pretty")
  -h, --help                  help for account-status
      --help-all              Show all commands and options, including administrative controls.
      --help-json             Print command input and output schemas as JSON without executing it.
      --module string         Defining deployed module, including .js
      --organization string   Organization context for provider settings
      --owner string          Connection owner: personal or organization
      --url string            Inspect account state, capabilities and sources on a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```

## bijection connection verify

```text theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Admit exact connection verification work

Usage:
  bijection connection verify <destination> <request-id> [flags]

Flags:
      --deployment string   Admit identity verification work on a specific deployment. Accepts:
                            • a deployment name (e.g. joyful-capybara-123)
                            • a deployment reference (e.g. dev/james, staging)
                            • dev (for your personal dev deployment)
                            • prod (for your project’s default production deployment).
                            You can also select deployments in other projects with project-slug:reference.
  -h, --help                help for identify
      --help-all            Show all commands and options, including administrative controls.
      --help-json           Print command input and output schemas as JSON without executing it.
      --url string          Admit identity verification work on a private deployment at this explicit origin.

Global Flags:
      --target string   Execution target: project/reference/live or project/reference/<branch>; private deployments use URL#live or URL#branch/<name>. Git navigation never changes this target.
```


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.