@burdenoff/sdk-libs 2026.627.3 → 2026.627.5

package/dist/modules/semanticfed/index.cjs

@@ -0,0 +1,283 @@
+'use strict';var y=`
+  fragment ConnectorScalars on SemConnector {
+    id name description kind isActive capabilities
+    workspaceId createdAt updatedAt
+  }
+`,d=`
+  fragment ConnectionFields on SemConnection {
+    id dataSourceId health latencyMs message probedAt
+    workspaceId createdAt updatedAt
+  }
+`,A=`
+  fragment DataSourceScalars on SemDataSource {
+    id connectorId name description endpoint pushdownEnabled secretRef
+    status tags lastIntrospectedAt workspaceId createdAt updatedAt
+  }
+`,E=`
+  fragment DimensionFields on SemDimension {
+    id entityId name dataType expression isPrimary description
+    workspaceId createdAt updatedAt
+  }
+`,D=`
+  fragment MetricFields on SemMetric {
+    id entityId name aggregation expression format description
+    workspaceId createdAt updatedAt
+  }
+`,S=`
+  fragment RelationshipFields on SemRelationship {
+    id modelId name fromEntityId fromField toEntityId toField kind description
+    workspaceId createdAt updatedAt
+  }
+`,p=`
+  fragment AccessPolicyFields on SemAccessPolicy {
+    id name description principal effect scope rule isActive entityId modelId
+    workspaceId createdAt updatedAt
+  }
+`,l=`
+  fragment QueryRunFields on SemQueryRun {
+    id queryId status fromCache rowCount sourcesTouched durationMs
+    planSummary errorMessage runById startedAt finishedAt
+    workspaceId createdAt updatedAt
+  }
+`,ce=`
+  fragment QueryScalars on SemQuery {
+    id modelId name description queryText parameters cacheable cacheTtlSeconds
+    status tags workspaceId createdAt updatedAt
+  }
+`,me=`
+  fragment ModelScalars on SemSemanticModel {
+    id name description status version tags publishedAt
+    workspaceId createdAt updatedAt
+  }
+`,a=`
+  fragment PageInfoFields on SemPageInfo { cursor hasMore }
+`,m=`
+  ${y}
+  ${A}
+  fragment ConnectorFull on SemConnector {
+    ...ConnectorScalars
+    dataSources { ...DataSourceScalars }
+  }
+`,o=`
+  ${A}
+  ${y}
+  ${d}
+  fragment DataSourceFull on SemDataSource {
+    ...DataSourceScalars
+    connector { ...ConnectorScalars }
+    connections { ...ConnectionFields }
+  }
+`,s=`
+  ${E}
+  ${D}
+  fragment EntityFull on SemEntity {
+    id modelId dataSourceId name kind physicalName primaryKey sqlDefinition
+    description workspaceId createdAt updatedAt
+    dimensions { ...DimensionFields }
+    metrics { ...MetricFields }
+  }
+`,r=`
+  ${me}
+  ${s}
+  ${S}
+  fragment ModelFull on SemSemanticModel {
+    ...ModelScalars
+    entities { ...EntityFull }
+    relationships { ...RelationshipFields }
+  }
+`,c=`
+  ${ce}
+  ${l}
+  fragment QueryFull on SemQuery {
+    ...QueryScalars
+    runs { ...QueryRunFields }
+  }
+`,R=`
+  ${m}
+  query SemGetConnector($id: ID!) { semConnector(id: $id) { ...ConnectorFull } }
+`,$=`
+  ${m}
+  ${a}
+  query SemListConnectors($kind: SemConnectorKind, $pagination: PaginationInput) {
+    semListConnectors(kind: $kind, pagination: $pagination) {
+      items { ...ConnectorFull }
+      pageInfo { ...PageInfoFields }
+    }
+  }
+`,F=`
+  ${m}
+  mutation SemCreateConnector($input: SemCreateConnectorInput!) {
+    semCreateConnector(input: $input) { ...ConnectorFull }
+  }
+`,T=`
+  ${m}
+  mutation SemUpdateConnector($id: ID!, $input: SemUpdateConnectorInput!) {
+    semUpdateConnector(id: $id, input: $input) { ...ConnectorFull }
+  }
+`,P=`
+  mutation SemArchiveConnector($id: ID!) { semArchiveConnector(id: $id) }
+`,_=`
+  ${o}
+  query SemGetDataSource($id: ID!) { semDataSource(id: $id) { ...DataSourceFull } }
+`,M=`
+  ${o}
+  ${a}
+  query SemListDataSources(
+    $connectorId: ID
+    $status: SemDataSourceStatus
+    $pagination: PaginationInput
+  ) {
+    semListDataSources(connectorId: $connectorId, status: $status, pagination: $pagination) {
+      items { ...DataSourceFull }
+      pageInfo { ...PageInfoFields }
+    }
+  }
+`,Q=`
+  ${o}
+  mutation SemCreateDataSource($input: SemCreateDataSourceInput!) {
+    semCreateDataSource(input: $input) { ...DataSourceFull }
+  }
+`,g=`
+  ${o}
+  mutation SemUpdateDataSource($id: ID!, $input: SemUpdateDataSourceInput!) {
+    semUpdateDataSource(id: $id, input: $input) { ...DataSourceFull }
+  }
+`,L=`
+  mutation SemArchiveDataSource($id: ID!) { semArchiveDataSource(id: $id) }
+`,h=`
+  ${o}
+  mutation SemTransitionDataSource($id: ID!, $status: SemDataSourceStatus!) {
+    semTransitionDataSource(id: $id, status: $status) { ...DataSourceFull }
+  }
+`,U=`
+  ${d}
+  query SemListConnections($dataSourceId: ID!) {
+    semListConnections(dataSourceId: $dataSourceId) { ...ConnectionFields }
+  }
+`,O=`
+  ${d}
+  mutation SemRecordConnection($input: SemRecordConnectionInput!) {
+    semRecordConnection(input: $input) { ...ConnectionFields }
+  }
+`,N=`
+  ${r}
+  query SemGetModel($id: ID!) { semModel(id: $id) { ...ModelFull } }
+`,q=`
+  ${r}
+  ${a}
+  query SemListModels($status: SemModelStatus, $pagination: PaginationInput) {
+    semListModels(status: $status, pagination: $pagination) {
+      items { ...ModelFull }
+      pageInfo { ...PageInfoFields }
+    }
+  }
+`,f=`
+  ${r}
+  mutation SemCreateModel($input: SemCreateModelInput!) {
+    semCreateModel(input: $input) { ...ModelFull }
+  }
+`,x=`
+  ${r}
+  mutation SemUpdateModel($id: ID!, $input: SemUpdateModelInput!) {
+    semUpdateModel(id: $id, input: $input) { ...ModelFull }
+  }
+`,w=`
+  mutation SemArchiveModel($id: ID!) { semArchiveModel(id: $id) }
+`,v=`
+  ${r}
+  mutation SemPublishModel($id: ID!) { semPublishModel(id: $id) { ...ModelFull } }
+`,H=`
+  ${s}
+  query SemGetEntity($id: ID!) { semEntity(id: $id) { ...EntityFull } }
+`,Y=`
+  ${s}
+  query SemListEntities($modelId: ID!) {
+    semListEntities(modelId: $modelId) { ...EntityFull }
+  }
+`,b=`
+  ${s}
+  mutation SemCreateEntity($input: SemCreateEntityInput!) {
+    semCreateEntity(input: $input) { ...EntityFull }
+  }
+`,k=`
+  ${s}
+  mutation SemUpdateEntity($id: ID!, $input: SemUpdateEntityInput!) {
+    semUpdateEntity(id: $id, input: $input) { ...EntityFull }
+  }
+`,G=`
+  mutation SemDeleteEntity($id: ID!) { semDeleteEntity(id: $id) }
+`,V=`
+  ${E}
+  mutation SemCreateDimension($input: SemCreateDimensionInput!) {
+    semCreateDimension(input: $input) { ...DimensionFields }
+  }
+`,K=`
+  ${D}
+  mutation SemCreateMetric($input: SemCreateMetricInput!) {
+    semCreateMetric(input: $input) { ...MetricFields }
+  }
+`,B=`
+  ${S}
+  query SemListRelationships($modelId: ID!) {
+    semListRelationships(modelId: $modelId) { ...RelationshipFields }
+  }
+`,j=`
+  ${S}
+  mutation SemCreateRelationship($input: SemCreateRelationshipInput!) {
+    semCreateRelationship(input: $input) { ...RelationshipFields }
+  }
+`,z=`
+  ${c}
+  query SemGetQuery($id: ID!) { semQuery(id: $id) { ...QueryFull } }
+`,J=`
+  ${c}
+  ${a}
+  query SemListQueries($modelId: ID, $status: SemQueryStatus, $pagination: PaginationInput) {
+    semListQueries(modelId: $modelId, status: $status, pagination: $pagination) {
+      items { ...QueryFull }
+      pageInfo { ...PageInfoFields }
+    }
+  }
+`,W=`
+  ${c}
+  mutation SemCreateQuery($input: SemCreateQueryInput!) {
+    semCreateQuery(input: $input) { ...QueryFull }
+  }
+`,X=`
+  ${c}
+  mutation SemUpdateQuery($id: ID!, $input: SemUpdateQueryInput!) {
+    semUpdateQuery(id: $id, input: $input) { ...QueryFull }
+  }
+`,Z=`
+  mutation SemArchiveQuery($id: ID!) { semArchiveQuery(id: $id) }
+`,ee=`
+  ${c}
+  mutation SemPublishQuery($id: ID!) { semPublishQuery(id: $id) { ...QueryFull } }
+`,te=`
+  ${l}
+  mutation SemRunQuery($id: ID!) { semRunQuery(id: $id) { ...QueryRunFields } }
+`,ne=`
+  ${l}
+  ${a}
+  query SemListQueryRuns($queryId: ID!, $status: SemQueryRunStatus, $pagination: PaginationInput) {
+    semListQueryRuns(queryId: $queryId, status: $status, pagination: $pagination) {
+      items { ...QueryRunFields }
+      pageInfo { ...PageInfoFields }
+    }
+  }
+`,ie=`
+  ${p}
+  query SemListAccessPolicies($entityId: ID, $modelId: ID) {
+    semListAccessPolicies(entityId: $entityId, modelId: $modelId) { ...AccessPolicyFields }
+  }
+`,ae=`
+  ${p}
+  mutation SemCreateAccessPolicy($input: SemCreateAccessPolicyInput!) {
+    semCreateAccessPolicy(input: $input) { ...AccessPolicyFields }
+  }
+`,oe=`
+  ${p}
+  mutation SemSetAccessPolicyActive($id: ID!, $isActive: Boolean!) {
+    semSetAccessPolicyActive(id: $id, isActive: $isActive) { ...AccessPolicyFields }
+  }
+`,se="query SemHealth { semHealth }";function re(u){let{workspace:n}=u.gql;return {connectors:{async get(e){return (await n.request(R,{id:e})).semConnector},async list(e,t){return (await n.request($,{kind:e,pagination:t})).semListConnectors},async create(e){return (await n.request(F,{input:e})).semCreateConnector},async update(e,t){return (await n.request(T,{id:e,input:t})).semUpdateConnector},async archive(e){return (await n.request(P,{id:e})).semArchiveConnector}},dataSources:{async get(e){return (await n.request(_,{id:e})).semDataSource},async list(e,t,i){return (await n.request(M,{connectorId:e,status:t,pagination:i})).semListDataSources},async create(e){return (await n.request(Q,{input:e})).semCreateDataSource},async update(e,t){return (await n.request(g,{id:e,input:t})).semUpdateDataSource},async archive(e){return (await n.request(L,{id:e})).semArchiveDataSource},async transition(e,t){return (await n.request(h,{id:e,status:t})).semTransitionDataSource}},connections:{async list(e){return (await n.request(U,{dataSourceId:e})).semListConnections},async record(e){return (await n.request(O,{input:e})).semRecordConnection}},models:{async get(e){return (await n.request(N,{id:e})).semModel},async list(e,t){return (await n.request(q,{status:e,pagination:t})).semListModels},async create(e){return (await n.request(f,{input:e})).semCreateModel},async update(e,t){return (await n.request(x,{id:e,input:t})).semUpdateModel},async archive(e){return (await n.request(w,{id:e})).semArchiveModel},async publish(e){return (await n.request(v,{id:e})).semPublishModel}},entities:{async get(e){return (await n.request(H,{id:e})).semEntity},async list(e){return (await n.request(Y,{modelId:e})).semListEntities},async create(e){return (await n.request(b,{input:e})).semCreateEntity},async update(e,t){return (await n.request(k,{id:e,input:t})).semUpdateEntity},async delete(e){return (await n.request(G,{id:e})).semDeleteEntity}},dimensions:{async create(e){return (await n.request(V,{input:e})).semCreateDimension}},metrics:{async create(e){return (await n.request(K,{input:e})).semCreateMetric}},relationships:{async list(e){return (await n.request(B,{modelId:e})).semListRelationships},async create(e){return (await n.request(j,{input:e})).semCreateRelationship}},queries:{async get(e){return (await n.request(z,{id:e})).semQuery},async list(e,t,i){return (await n.request(J,{modelId:e,status:t,pagination:i})).semListQueries},async create(e){return (await n.request(W,{input:e})).semCreateQuery},async update(e,t){return (await n.request(X,{id:e,input:t})).semUpdateQuery},async archive(e){return (await n.request(Z,{id:e})).semArchiveQuery},async publish(e){return (await n.request(ee,{id:e})).semPublishQuery},async run(e){return (await n.request(te,{id:e})).semRunQuery}},queryRuns:{async list(e,t,i){return (await n.request(ne,{queryId:e,status:t,pagination:i})).semListQueryRuns}},accessPolicies:{async list(e,t){return (await n.request(ie,{entityId:e,modelId:t})).semListAccessPolicies},async create(e){return (await n.request(ae,{input:e})).semCreateAccessPolicy},async setActive(e,t){return (await n.request(oe,{id:e,isActive:t})).semSetAccessPolicyActive}},health:{async check(){return (await n.request(se)).semHealth}}}}var ue={id:"semanticfed",version:"1.0.0",displayName:"SemanticFed",dependsOn:["auth"],attach(u){return re(u)}},ge=ue;module.exports=ge;

package/dist/modules/semanticfed/index.d.cts

@@ -0,0 +1,404 @@
+import { J as Json, S as SdkModule } from '../../module-JDbvil5h.cjs';
+import 'graphql-request';
+
+type SemAggregation = 'AVG' | 'COUNT' | 'COUNT_DISTINCT' | 'CUSTOM' | 'MAX' | 'MEDIAN' | 'MIN' | 'SUM';
+type SemConnectionHealth = 'DEGRADED' | 'HEALTHY' | 'UNKNOWN' | 'UNREACHABLE';
+type SemConnectorKind = 'BIGQUERY' | 'CLICKHOUSE' | 'DATABRICKS' | 'GRAPHQL_API' | 'MONGODB' | 'MYSQL' | 'OTHER' | 'POSTGRES' | 'REDSHIFT' | 'REST_API' | 'S3_PARQUET' | 'SNOWFLAKE';
+type SemDataSourceStatus = 'CONNECTED' | 'DEGRADED' | 'DISABLED' | 'DISCONNECTED' | 'DRAFT';
+type SemDataType = 'BOOLEAN' | 'DATE' | 'DECIMAL' | 'GEO' | 'INTEGER' | 'JSON' | 'STRING' | 'TIMESTAMP';
+type SemEntityKind = 'DERIVED' | 'EXTERNAL' | 'TABLE' | 'VIEW';
+type SemModelStatus = 'ARCHIVED' | 'DEPRECATED' | 'DRAFT' | 'PUBLISHED';
+type SemPolicyEffect = 'ALLOW' | 'DENY';
+type SemPolicyScope = 'COLUMN' | 'ENTITY' | 'ROW';
+type SemQueryRunStatus = 'CANCELLED' | 'FAILED' | 'PLANNING' | 'QUEUED' | 'RUNNING' | 'SUCCEEDED';
+type SemQueryStatus = 'ARCHIVED' | 'DRAFT' | 'PUBLISHED';
+type SemRelationshipKind = 'MANY_TO_MANY' | 'MANY_TO_ONE' | 'ONE_TO_MANY' | 'ONE_TO_ONE';
+interface SemPageInfo {
+    cursor?: string | null;
+    hasMore: boolean;
+}
+interface SemConnector {
+    id: string;
+    name: string;
+    description?: string | null;
+    kind: SemConnectorKind;
+    isActive: boolean;
+    capabilities?: Json | null;
+    dataSources: SemDataSource[];
+    workspaceId: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SemConnection {
+    id: string;
+    dataSourceId: string;
+    health: SemConnectionHealth;
+    latencyMs?: number | null;
+    message?: string | null;
+    probedAt: string;
+    workspaceId: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SemDataSource {
+    id: string;
+    connectorId: string;
+    connector?: SemConnector | null;
+    connections: SemConnection[];
+    name: string;
+    description?: string | null;
+    endpoint?: Json | null;
+    pushdownEnabled: boolean;
+    secretRef?: string | null;
+    status: SemDataSourceStatus;
+    tags: string[];
+    lastIntrospectedAt?: string | null;
+    workspaceId: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SemDimension {
+    id: string;
+    entityId: string;
+    name: string;
+    dataType: SemDataType;
+    expression?: string | null;
+    isPrimary: boolean;
+    description?: string | null;
+    workspaceId: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SemMetric {
+    id: string;
+    entityId: string;
+    name: string;
+    aggregation: SemAggregation;
+    expression?: string | null;
+    format?: string | null;
+    description?: string | null;
+    workspaceId: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SemEntity {
+    id: string;
+    modelId: string;
+    dataSourceId?: string | null;
+    name: string;
+    kind: SemEntityKind;
+    physicalName?: string | null;
+    primaryKey?: string | null;
+    sqlDefinition?: string | null;
+    description?: string | null;
+    dimensions: SemDimension[];
+    metrics: SemMetric[];
+    workspaceId: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SemRelationship {
+    id: string;
+    modelId: string;
+    name: string;
+    fromEntityId: string;
+    fromField: string;
+    toEntityId: string;
+    toField: string;
+    kind: SemRelationshipKind;
+    description?: string | null;
+    workspaceId: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SemSemanticModel {
+    id: string;
+    name: string;
+    description?: string | null;
+    status: SemModelStatus;
+    version: number;
+    tags: string[];
+    publishedAt?: string | null;
+    entities: SemEntity[];
+    relationships: SemRelationship[];
+    workspaceId: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SemQueryRun {
+    id: string;
+    queryId: string;
+    status: SemQueryRunStatus;
+    fromCache: boolean;
+    rowCount?: number | null;
+    sourcesTouched: number;
+    durationMs?: number | null;
+    planSummary?: Json | null;
+    errorMessage?: string | null;
+    runById?: string | null;
+    startedAt?: string | null;
+    finishedAt?: string | null;
+    workspaceId: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SemQuery {
+    id: string;
+    modelId?: string | null;
+    name: string;
+    description?: string | null;
+    queryText: string;
+    parameters?: Json | null;
+    cacheable: boolean;
+    cacheTtlSeconds: number;
+    status: SemQueryStatus;
+    tags: string[];
+    runs: SemQueryRun[];
+    workspaceId: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SemAccessPolicy {
+    id: string;
+    name: string;
+    description?: string | null;
+    principal: string;
+    effect: SemPolicyEffect;
+    scope: SemPolicyScope;
+    rule?: Json | null;
+    isActive: boolean;
+    entityId?: string | null;
+    modelId?: string | null;
+    workspaceId: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SemConnectorConnection {
+    items: SemConnector[];
+    pageInfo: SemPageInfo;
+}
+interface SemDataSourceConnection {
+    items: SemDataSource[];
+    pageInfo: SemPageInfo;
+}
+interface SemSemanticModelConnection {
+    items: SemSemanticModel[];
+    pageInfo: SemPageInfo;
+}
+interface SemQueryConnection {
+    items: SemQuery[];
+    pageInfo: SemPageInfo;
+}
+interface SemQueryRunConnection {
+    items: SemQueryRun[];
+    pageInfo: SemPageInfo;
+}
+interface SemPaginationInput {
+    cursor?: string;
+    limit?: number;
+    offset?: number;
+}
+interface SemCreateConnectorInput {
+    name: string;
+    capabilities?: Json;
+    description?: string;
+    kind?: SemConnectorKind;
+}
+interface SemUpdateConnectorInput {
+    capabilities?: Json;
+    description?: string;
+    isActive?: boolean;
+    kind?: SemConnectorKind;
+    name?: string;
+}
+interface SemCreateDataSourceInput {
+    connectorId: string;
+    name: string;
+    description?: string;
+    endpoint?: Json;
+    pushdownEnabled?: boolean;
+    secretRef?: string;
+    tags?: string[];
+}
+interface SemUpdateDataSourceInput {
+    description?: string;
+    endpoint?: Json;
+    name?: string;
+    pushdownEnabled?: boolean;
+    secretRef?: string;
+    tags?: string[];
+}
+interface SemRecordConnectionInput {
+    dataSourceId: string;
+    health: SemConnectionHealth;
+    latencyMs?: number;
+    message?: string;
+}
+interface SemCreateModelInput {
+    name: string;
+    description?: string;
+    tags?: string[];
+}
+interface SemUpdateModelInput {
+    description?: string;
+    name?: string;
+    tags?: string[];
+}
+interface SemCreateEntityInput {
+    modelId: string;
+    name: string;
+    dataSourceId?: string;
+    description?: string;
+    kind?: SemEntityKind;
+    physicalName?: string;
+    primaryKey?: string;
+    sqlDefinition?: string;
+}
+interface SemUpdateEntityInput {
+    dataSourceId?: string;
+    description?: string;
+    kind?: SemEntityKind;
+    name?: string;
+    physicalName?: string;
+    primaryKey?: string;
+    sqlDefinition?: string;
+}
+interface SemCreateDimensionInput {
+    entityId: string;
+    name: string;
+    dataType?: SemDataType;
+    description?: string;
+    expression?: string;
+    isPrimary?: boolean;
+}
+interface SemCreateMetricInput {
+    entityId: string;
+    name: string;
+    aggregation?: SemAggregation;
+    description?: string;
+    expression?: string;
+    format?: string;
+}
+interface SemCreateRelationshipInput {
+    modelId: string;
+    name: string;
+    fromEntityId: string;
+    fromField: string;
+    toEntityId: string;
+    toField: string;
+    description?: string;
+    kind?: SemRelationshipKind;
+}
+interface SemCreateQueryInput {
+    name: string;
+    queryText: string;
+    cacheTtlSeconds?: number;
+    cacheable?: boolean;
+    description?: string;
+    modelId?: string;
+    parameters?: Json;
+    tags?: string[];
+}
+interface SemUpdateQueryInput {
+    cacheTtlSeconds?: number;
+    cacheable?: boolean;
+    description?: string;
+    modelId?: string;
+    name?: string;
+    parameters?: Json;
+    queryText?: string;
+    tags?: string[];
+}
+interface SemCreateAccessPolicyInput {
+    name: string;
+    principal: string;
+    description?: string;
+    effect?: SemPolicyEffect;
+    entityId?: string;
+    modelId?: string;
+    rule?: Json;
+    scope?: SemPolicyScope;
+}
+
+interface SemanticFedConnectorsApi {
+    get(id: string): Promise<SemConnector | null>;
+    list(kind?: SemConnectorKind, pagination?: SemPaginationInput): Promise<SemConnectorConnection>;
+    create(input: SemCreateConnectorInput): Promise<SemConnector>;
+    update(id: string, input: SemUpdateConnectorInput): Promise<SemConnector>;
+    archive(id: string): Promise<boolean>;
+}
+interface SemanticFedDataSourcesApi {
+    get(id: string): Promise<SemDataSource | null>;
+    list(connectorId?: string, status?: SemDataSourceStatus, pagination?: SemPaginationInput): Promise<SemDataSourceConnection>;
+    create(input: SemCreateDataSourceInput): Promise<SemDataSource>;
+    update(id: string, input: SemUpdateDataSourceInput): Promise<SemDataSource>;
+    archive(id: string): Promise<boolean>;
+    transition(id: string, status: SemDataSourceStatus): Promise<SemDataSource>;
+}
+interface SemanticFedConnectionsApi {
+    list(dataSourceId: string): Promise<SemConnection[]>;
+    record(input: SemRecordConnectionInput): Promise<SemConnection>;
+}
+interface SemanticFedModelsApi {
+    get(id: string): Promise<SemSemanticModel | null>;
+    list(status?: SemModelStatus, pagination?: SemPaginationInput): Promise<SemSemanticModelConnection>;
+    create(input: SemCreateModelInput): Promise<SemSemanticModel>;
+    update(id: string, input: SemUpdateModelInput): Promise<SemSemanticModel>;
+    archive(id: string): Promise<boolean>;
+    publish(id: string): Promise<SemSemanticModel>;
+}
+interface SemanticFedEntitiesApi {
+    get(id: string): Promise<SemEntity | null>;
+    list(modelId: string): Promise<SemEntity[]>;
+    create(input: SemCreateEntityInput): Promise<SemEntity>;
+    update(id: string, input: SemUpdateEntityInput): Promise<SemEntity>;
+    delete(id: string): Promise<boolean>;
+}
+interface SemanticFedDimensionsApi {
+    create(input: SemCreateDimensionInput): Promise<SemDimension>;
+}
+interface SemanticFedMetricsApi {
+    create(input: SemCreateMetricInput): Promise<SemMetric>;
+}
+interface SemanticFedRelationshipsApi {
+    list(modelId: string): Promise<SemRelationship[]>;
+    create(input: SemCreateRelationshipInput): Promise<SemRelationship>;
+}
+interface SemanticFedQueriesApi {
+    get(id: string): Promise<SemQuery | null>;
+    list(modelId?: string, status?: SemQueryStatus, pagination?: SemPaginationInput): Promise<SemQueryConnection>;
+    create(input: SemCreateQueryInput): Promise<SemQuery>;
+    update(id: string, input: SemUpdateQueryInput): Promise<SemQuery>;
+    archive(id: string): Promise<boolean>;
+    publish(id: string): Promise<SemQuery>;
+    run(id: string): Promise<SemQueryRun>;
+}
+interface SemanticFedQueryRunsApi {
+    list(queryId: string, status?: SemQueryRunStatus, pagination?: SemPaginationInput): Promise<SemQueryRunConnection>;
+}
+interface SemanticFedAccessPoliciesApi {
+    list(entityId?: string, modelId?: string): Promise<SemAccessPolicy[]>;
+    create(input: SemCreateAccessPolicyInput): Promise<SemAccessPolicy>;
+    setActive(id: string, isActive: boolean): Promise<SemAccessPolicy>;
+}
+interface SemanticFedHealthApi {
+    check(): Promise<string>;
+}
+interface SemanticFedApi {
+    connectors: SemanticFedConnectorsApi;
+    dataSources: SemanticFedDataSourcesApi;
+    connections: SemanticFedConnectionsApi;
+    models: SemanticFedModelsApi;
+    entities: SemanticFedEntitiesApi;
+    dimensions: SemanticFedDimensionsApi;
+    metrics: SemanticFedMetricsApi;
+    relationships: SemanticFedRelationshipsApi;
+    queries: SemanticFedQueriesApi;
+    queryRuns: SemanticFedQueryRunsApi;
+    accessPolicies: SemanticFedAccessPoliciesApi;
+    health: SemanticFedHealthApi;
+}
+
+declare const semanticfedModule: SdkModule<SemanticFedApi>;
+
+export { type SemAccessPolicy, type SemAggregation, type SemConnection, type SemConnectionHealth, type SemConnector, type SemConnectorConnection, type SemConnectorKind, type SemCreateAccessPolicyInput, type SemCreateConnectorInput, type SemCreateDataSourceInput, type SemCreateDimensionInput, type SemCreateEntityInput, type SemCreateMetricInput, type SemCreateModelInput, type SemCreateQueryInput, type SemCreateRelationshipInput, type SemDataSource, type SemDataSourceConnection, type SemDataSourceStatus, type SemDataType, type SemDimension, type SemEntity, type SemEntityKind, type SemMetric, type SemModelStatus, type SemPageInfo, type SemPaginationInput, type SemPolicyEffect, type SemPolicyScope, type SemQuery, type SemQueryConnection, type SemQueryRun, type SemQueryRunConnection, type SemQueryRunStatus, type SemQueryStatus, type SemRecordConnectionInput, type SemRelationship, type SemRelationshipKind, type SemSemanticModel, type SemSemanticModelConnection, type SemUpdateConnectorInput, type SemUpdateDataSourceInput, type SemUpdateEntityInput, type SemUpdateModelInput, type SemUpdateQueryInput, type SemanticFedAccessPoliciesApi, type SemanticFedApi, type SemanticFedConnectionsApi, type SemanticFedConnectorsApi, type SemanticFedDataSourcesApi, type SemanticFedDimensionsApi, type SemanticFedEntitiesApi, type SemanticFedHealthApi, type SemanticFedMetricsApi, type SemanticFedModelsApi, type SemanticFedQueriesApi, type SemanticFedQueryRunsApi, type SemanticFedRelationshipsApi, semanticfedModule as default };